@aptos-labs/ts-sdk 0.0.0

package/src/api/aptos.ts

@@ -0,0 +1,103 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Account } from "./account";
+import { AptosConfig } from "./aptosConfig";
+import { Coin } from "./coin";
+import { DigitalAsset } from "./digitalAsset";
+import { Event } from "./event";
+import { Faucet } from "./faucet";
+import { FungibleAsset } from "./fungibleAsset";
+import { General } from "./general";
+import { Staking } from "./staking";
+import { Transaction } from "./transaction";
+import { TransactionSubmission } from "./transactionSubmission";
+
+/**
+ * This class is the main entry point into Aptos's
+ * APIs and separates functionality into different namespaces.
+ *
+ * To use the SDK, create a new Aptos instance to get access
+ * to all the sdk functionality.
+ */
+export class Aptos {
+  readonly config: AptosConfig;
+
+  readonly account: Account;
+
+  readonly coin: Coin;
+
+  readonly digitalAsset: DigitalAsset;
+
+  readonly event: Event;
+
+  readonly faucet: Faucet;
+
+  readonly fungibleAsset: FungibleAsset;
+
+  readonly general: General;
+
+  readonly staking: Staking;
+
+  readonly transaction: Transaction;
+
+  readonly transactionSubmission: TransactionSubmission;
+
+  constructor(settings?: AptosConfig) {
+    this.config = new AptosConfig(settings);
+    this.account = new Account(this.config);
+    this.coin = new Coin(this.config);
+    this.digitalAsset = new DigitalAsset(this.config);
+    this.event = new Event(this.config);
+    this.faucet = new Faucet(this.config);
+    this.fungibleAsset = new FungibleAsset(this.config);
+    this.general = new General(this.config);
+    this.staking = new Staking(this.config);
+    this.transaction = new Transaction(this.config);
+    this.transactionSubmission = new TransactionSubmission(this.config);
+  }
+}
+
+export interface Aptos
+  extends Account,
+    Coin,
+    DigitalAsset,
+    Event,
+    Faucet,
+    FungibleAsset,
+    General,
+    Staking,
+    Transaction,
+    TransactionSubmission {}
+
+/**
+In TypeScript, we can’t inherit or extend from more than one class,
+Mixins helps us to get around that by creating a partial classes 
+that we can combine to form a single class that contains all the methods and properties from the partial classes.
+{@link https://www.typescriptlang.org/docs/handbook/mixins.html#alternative-pattern}
+
+Here, we combine any subclass and the Aptos class.
+*/
+function applyMixin(targetClass: any, baseClass: any, baseClassProp: string) {
+  // Mixin instance methods
+  Object.getOwnPropertyNames(baseClass.prototype).forEach((propertyName) => {
+    const propertyDescriptor = Object.getOwnPropertyDescriptor(baseClass.prototype, propertyName);
+    if (!propertyDescriptor) return;
+    // eslint-disable-next-line func-names
+    propertyDescriptor.value = function (...args: any) {
+      return (this as any)[baseClassProp][propertyName](...args);
+    };
+    Object.defineProperty(targetClass.prototype, propertyName, propertyDescriptor);
+  });
+}
+
+applyMixin(Aptos, Account, "account");
+applyMixin(Aptos, Coin, "coin");
+applyMixin(Aptos, DigitalAsset, "digitalAsset");
+applyMixin(Aptos, Event, "event");
+applyMixin(Aptos, Faucet, "faucet");
+applyMixin(Aptos, FungibleAsset, "fungibleAsset");
+applyMixin(Aptos, General, "general");
+applyMixin(Aptos, Staking, "staking");
+applyMixin(Aptos, Transaction, "transaction");
+applyMixin(Aptos, TransactionSubmission, "transactionSubmission");

package/src/api/aptosConfig.ts

@@ -0,0 +1,77 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { AptosSettings, ClientConfig } from "../types";
+import { NetworkToNodeAPI, NetworkToFaucetAPI, NetworkToIndexerAPI, Network } from "../utils/apiEndpoints";
+import { AptosApiType, DEFAULT_NETWORK } from "../utils/const";
+
+/**
+ * This class holds the config information for the SDK client instance.
+ */
+export class AptosConfig {
+  /** The Network that this SDK is associated with. */
+  readonly network: Network;
+
+  /**
+   * The optional hardcoded fullnode URL to send requests to instead of using the network
+   */
+  readonly fullnode?: string;
+
+  /**
+   * The optional hardcoded faucet URL to send requests to instead of using the network
+   */
+  readonly faucet?: string;
+
+  /**
+   * The optional hardcoded indexer URL to send requests to instead of using the network
+   */
+  readonly indexer?: string;
+
+  readonly clientConfig?: ClientConfig;
+
+  constructor(settings?: AptosSettings) {
+    this.network = settings?.network ?? DEFAULT_NETWORK;
+    this.fullnode = settings?.fullnode;
+    this.faucet = settings?.faucet;
+    this.indexer = settings?.indexer;
+    this.clientConfig = settings?.clientConfig ?? {};
+  }
+
+  /**
+   * Returns the URL endpoint to send the request to.
+   * If a custom URL was provided in the config, that URL is returned.
+   * If a custom URL was provided but not URL endpoints, an error is thrown.
+   * Otherwise, the URL endpoint is derived from the network.
+   *
+   * @param apiType - The type of Aptos API to get the URL for.
+   *
+   * @internal
+   */
+  getRequestUrl(apiType: AptosApiType): string {
+    switch (apiType) {
+      case AptosApiType.FULLNODE:
+        if (this.fullnode !== undefined) return this.fullnode;
+        if (this.network === Network.CUSTOM) throw new Error("Please provide a custom full node url");
+        return NetworkToNodeAPI[this.network];
+      case AptosApiType.FAUCET:
+        if (this.faucet !== undefined) return this.faucet;
+        if (this.network === Network.CUSTOM) throw new Error("Please provide a custom faucet url");
+        return NetworkToFaucetAPI[this.network];
+      case AptosApiType.INDEXER:
+        if (this.indexer !== undefined) return this.indexer;
+        if (this.network === Network.CUSTOM) throw new Error("Please provide a custom indexer url");
+        return NetworkToIndexerAPI[this.network];
+      default:
+        throw Error(`apiType ${apiType} is not supported`);
+    }
+  }
+
+  /**
+   * Checks if the URL is a known indexer endpoint
+   *
+   * @internal
+   * */
+  isIndexerRequest(url: string): boolean {
+    return NetworkToIndexerAPI[this.network] === url;
+  }
+}

package/src/api/coin.ts

@@ -0,0 +1,39 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { AptosConfig } from "./aptosConfig";
+import { Account } from "../core";
+import { transferCoinTransaction } from "../internal/coin";
+import { SingleSignerTransaction, GenerateTransactionOptions } from "../transactions/types";
+import { AnyNumber, HexInput, MoveResourceType } from "../types";
+
+/**
+ * A class to handle all `Coin` operations
+ */
+export class Coin {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Generate a transfer coin transaction that can be simulated and/or signed and submitted
+   *
+   * @param args.sender The sender account
+   * @param args.recipient The recipient address
+   * @param args.amount The amount to transfer
+   * @param args.coinType optional. The coin struct type to transfer. Defaults to 0x1::aptos_coin::AptosCoin
+   *
+   * @returns SingleSignerTransaction
+   */
+  async transferCoinTransaction(args: {
+    sender: Account;
+    recipient: HexInput;
+    amount: AnyNumber;
+    coinType?: MoveResourceType;
+    options?: GenerateTransactionOptions;
+  }): Promise<SingleSignerTransaction> {
+    return transferCoinTransaction({ aptosConfig: this.config, ...args });
+  }
+}

package/src/api/digitalAsset.ts

@@ -0,0 +1,192 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+  GetCollectionDataResponse,
+  GetCurrentTokenOwnershipResponse,
+  GetOwnedTokensResponse,
+  GetTokenActivityResponse,
+  GetTokenDataResponse,
+  HexInput,
+  OrderBy,
+  PaginationArgs,
+  TokenStandard,
+} from "../types";
+import { AptosConfig } from "./aptosConfig";
+import { Account } from "../core";
+import { GenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
+import {
+  CreateCollectionOptions,
+  createCollectionTransaction,
+  getCollectionData,
+  getCollectionId,
+  getCurrentTokenOwnership,
+  getOwnedTokens,
+  getTokenActivity,
+  getTokenData,
+  mintTokenTransaction,
+} from "../internal/digitalAsset";
+
+/**
+ * A class to query all `DigitalAsset` related queries on Aptos.
+ */
+export class DigitalAsset {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Creates a new collection within the specified account
+   *
+   * @param args.creator the account of the collection's creator
+   * @param args.description the description of the collection
+   * @param args.name the name of the collection
+   * @param args.uri the URI to additional info about the collection
+   *
+   * The parameters below are optional.
+   * @param args.maxSupply controls the max supply of the tokens - defaults MAX_U64_BIG_INT
+   * @param args.mutableDescription controls mutability of the collection's description - defaults true
+   * @param args.mutableRoyalty controls mutability of the collection's description - defaults true
+   * @param args.mutableUri controls mutability of the collection's URI - defaults true
+   * @param args.mutableTokenDescription controls mutability of the token's description - defaults true
+   * @param args.mutableTokenName controls mutability of the token's name - defaults true
+   * @param args.mutableTokenProperties controls mutability of token's properties - defaults true
+   * @param args.mutableTokenUri controls mutability of the token's URI - defaults true
+   * @param args.tokensBurnableByCreator controls whether tokens can be burnable by the creator - defaults true
+   * @param args.tokensFreezableByCreator controls whether tokens can be frozen by the creator - defaults true
+   * @param args.royaltyNumerator the numerator of the royalty to be paid to the creator when a token is transferred - defaults 0
+   * @param args.royaltyDenominator the denominator of the royalty to be paid to the creator when a token is transferred -
+   *    defaults 1
+   *
+   * @returns A SingleSignerTransaction that when submitted will create the collection.
+   */
+  async createCollectionTransaction(
+    args: {
+      creator: Account;
+      description: string;
+      name: string;
+      uri: string;
+      options?: GenerateTransactionOptions;
+    } & CreateCollectionOptions,
+  ): Promise<SingleSignerTransaction> {
+    return createCollectionTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Queries data of a specific collection by the collection creator address and the collection name.
+   *
+   * If, for some reason, a creator account has 2 collections with the same name in v1 and v2,
+   * can pass an optional `tokenStandard` parameter to query a specific standard
+   *
+   * @param args.creatorAddress the address of the collection's creator
+   * @param args.collectionName the name of the collection
+   * @param args.options.tokenStandard the token standard to query
+   * @returns GetCollectionDataResponse response type
+   */
+  async getCollectionData(args: {
+    creatorAddress: HexInput;
+    collectionName: string;
+    options?: {
+      tokenStandard?: TokenStandard;
+    };
+  }): Promise<GetCollectionDataResponse> {
+    return getCollectionData({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Queries a collection's ID.
+   *
+   * This is the same as the collection's object address in V2, but V1 does
+   * not use objects, and does not have an address
+   *
+   * @param args.creatorAddress the address of the collection's creator
+   * @param args.collectionName the name of the collection
+   * @param args.options.tokenStandard the token standard to query
+   * @returns the collection id
+   */
+  async getCollectionId(args: {
+    creatorAddress: HexInput;
+    collectionName: string;
+    options?: {
+      tokenStandard?: TokenStandard;
+    };
+  }): Promise<string> {
+    return getCollectionId({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Create a transaction to mint a token into the creators account within an existing collection.
+   *
+   * @param args.creator the creator of the collection
+   * @param args.collection the name of the collection the token belongs to
+   * @param args.description the description of the token
+   * @param args.name the name of the token
+   * @param args.uri the URI to additional info about the token
+   *
+   * @returns A SingleSignerTransaction that can be simulated or submitted to chain
+   */
+  async mintTokenTransaction(args: {
+    creator: Account;
+    collection: string;
+    description: string;
+    name: string;
+    uri: string;
+    options?: GenerateTransactionOptions;
+  }): Promise<SingleSignerTransaction> {
+    return mintTokenTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Gets token data given the address of a token.
+   *
+   * @param args.tokenAddress The address of the token
+   * @returns GetTokenDataResponse containing relevant data to the token.
+   */
+  async getTokenData(args: { tokenAddress: HexInput }): Promise<GetTokenDataResponse> {
+    return getTokenData({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Gets token ownership data given the address of a token.
+   *
+   * @param args.tokenAddress The address of the token
+   * @returns GetCurrentTokenOwnershipResponse containing relevant ownership data of the token.
+   */
+  async getCurrentTokenOwnership(args: { tokenAddress: HexInput }): Promise<GetCurrentTokenOwnershipResponse> {
+    return getCurrentTokenOwnership({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Gets the tokens that the given address owns.
+   *
+   * @param args.ownerAddress The address of the owner
+   * @returns GetOwnedTokensResponse containing ownership data of the tokens belonging to the ownerAddresss.
+   */
+  async getOwnedTokens(args: {
+    ownerAddress: HexInput;
+    options?: {
+      pagination?: PaginationArgs;
+      orderBy?: OrderBy<GetOwnedTokensResponse[0]>;
+    };
+  }): Promise<GetOwnedTokensResponse> {
+    return getOwnedTokens({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Gets the activity data given the address of a token.
+   *
+   * @param args.tokenAddress The address of the token
+   * @returns GetTokenActivityResponse containing relevant activity data to the token.
+   */
+  async getTokenActivity(args: {
+    tokenAddress: HexInput;
+    options?: {
+      pagination?: PaginationArgs;
+      orderBy?: OrderBy<GetTokenActivityResponse[0]>;
+    };
+  }): Promise<GetTokenActivityResponse> {
+    return getTokenActivity({ aptosConfig: this.config, ...args });
+  }
+}

package/src/api/event.ts

@@ -0,0 +1,78 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { AptosConfig } from "./aptosConfig";
+import { getAccountEventsByCreationNumber, getAccountEventsByEventType, getEvents } from "../internal/event";
+import { AnyNumber, GetEventsResponse, HexInput, MoveResourceType, OrderBy, PaginationArgs } from "../types";
+import { EventsBoolExp } from "../types/generated/types";
+
+/**
+ * A class to query all `Event` Aptos related queries
+ */
+export class Event {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Get events by creation number and an account address
+   *
+   * @param args.accountAddress - The account address
+   * @param args.creationNumber - The event creation number
+   *
+   * @returns Promise<GetEventsResponse>
+   */
+  async getAccountEventsByCreationNumber(args: {
+    accountAddress: HexInput;
+    creationNumber: AnyNumber;
+  }): Promise<GetEventsResponse> {
+    return getAccountEventsByCreationNumber({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Get events by event type and an account address
+   *
+   * @param args.accountAddress - The account address
+   * @param args.eventType - The event type
+   *
+   * @returns Promise<GetEventsResponse>
+   */
+  async getAccountEventsByEventType(args: {
+    accountAddress: HexInput;
+    eventType: MoveResourceType;
+    options?: {
+      pagination?: PaginationArgs;
+      orderBy?: OrderBy<GetEventsResponse[0]>;
+    };
+  }): Promise<GetEventsResponse> {
+    return getAccountEventsByEventType({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Get all events
+   *
+   * An optional `where` can be passed in to filter out the response.
+   *
+   * @example
+   * ```
+   * { where:
+   *  {
+   *   transaction_version: { _eq: 123456 },
+   *  }
+   * }
+   * ```
+   *
+   * @returns GetEventsQuery response type
+   */
+  async getEvents(args?: {
+    options?: {
+      where?: EventsBoolExp;
+      pagination?: PaginationArgs;
+      orderBy?: OrderBy<GetEventsResponse[0]>;
+    };
+  }): Promise<GetEventsResponse> {
+    return getEvents({ aptosConfig: this.config, ...args });
+  }
+}

package/src/api/faucet.ts

@@ -0,0 +1,30 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { AptosConfig } from "./aptosConfig";
+import { fundAccount } from "../internal/faucet";
+import { HexInput } from "../types";
+
+/**
+ * A class to query all `Faucet` related queries on Aptos.
+ */
+export class Faucet {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  /**
+   * This creates an account if it does not exist and mints the specified amount of
+   * coins into that account
+   *
+   * @param args.accountAddress Address of the account to fund
+   * @param args.amount Amount of tokens to fund the account with
+   * @param args.timeoutSecs Timeout in seconds. Defaults to 20 seconds.
+   * @returns Transaction hash of the transaction that funded the account
+   */
+  async fundAccount(args: { accountAddress: HexInput; amount: number; timeoutSecs?: number }): Promise<string> {
+    return fundAccount({ aptosConfig: this.config, ...args });
+  }
+}

package/src/api/fungibleAsset.ts

@@ -0,0 +1,82 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+  GetCurrentFungibleAssetBalancesResponse,
+  GetFungibleAssetActivitiesResponse,
+  GetFungibleAssetMetadataResponse,
+  PaginationArgs,
+} from "../types";
+import { AptosConfig } from "./aptosConfig";
+import {
+  getCurrentFungibleAssetBalances,
+  getFungibleAssetActivities,
+  getFungibleAssetMetadata,
+} from "../internal/fungibleAsset";
+import {
+  CurrentFungibleAssetBalancesBoolExp,
+  FungibleAssetActivitiesBoolExp,
+  FungibleAssetMetadataBoolExp,
+} from "../types/generated/types";
+
+/**
+ * A class to query all `FungibleAsset` related queries on Aptos.
+ */
+export class FungibleAsset {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Queries the current fungible asset metadata.
+   *
+   * This query returns the fungible asset metadata for all fungible assets.
+   * It can be filtered by creator address and asset type.
+   *
+   * @returns getFungibleAssetMetadata A list of fungible asset metadata
+   */
+  async getFungibleAssetMetadata(args?: {
+    options?: {
+      pagination?: PaginationArgs;
+      where?: FungibleAssetMetadataBoolExp;
+    };
+  }): Promise<GetFungibleAssetMetadataResponse> {
+    return getFungibleAssetMetadata({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Queries the fungible asset activities
+   *
+   * This query returns the fungible asset activities.
+   * It can be filtered by owner address, asset type, and type.
+   *
+   * @returns GetFungibleAssetActivitiesResponse A list of fungible asset metadata
+   */
+  async getFungibleAssetActivities(args?: {
+    options?: {
+      pagination?: PaginationArgs;
+      where?: FungibleAssetActivitiesBoolExp;
+    };
+  }): Promise<GetFungibleAssetActivitiesResponse> {
+    return getFungibleAssetActivities({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Queries the fungible asset balance
+   *
+   * This query returns the fungible asset balance.
+   * It can be filtered by owner address, and asset type
+   *
+   * @returns GetCurrentFungibleAssetBalancesResponse A list of fungible asset metadata
+   */
+  async getCurrentFungibleAssetBalances(args?: {
+    options?: {
+      pagination?: PaginationArgs;
+      where?: CurrentFungibleAssetBalancesBoolExp;
+    };
+  }): Promise<GetCurrentFungibleAssetBalancesResponse> {
+    return getCurrentFungibleAssetBalances({ aptosConfig: this.config, ...args });
+  }
+}