@aptos-labs/ts-sdk 0.0.0

package/src/internal/digitalAsset.ts

@@ -0,0 +1,302 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/digitalAsset}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * digitalAsset namespace and without having a dependency cycle error.
+ */
+
+import { AptosConfig } from "../api/aptosConfig";
+import { MoveString, MoveVector, Bool, U64, U8 } from "../bcs";
+import { Account, Hex } from "../core";
+import { GenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
+import {
+  AnyNumber,
+  GetCollectionDataResponse,
+  GetCurrentTokenOwnershipResponse,
+  GetOwnedTokensResponse,
+  GetTokenActivityResponse,
+  GetTokenDataResponse,
+  HexInput,
+  OrderBy,
+  PaginationArgs,
+  TokenStandard,
+} from "../types";
+import {
+  GetCollectionDataQuery,
+  GetCurrentTokenOwnershipQuery,
+  GetTokenActivityQuery,
+  GetTokenDataQuery,
+} from "../types/generated/operations";
+import {
+  GetCollectionData,
+  GetCurrentTokenOwnership,
+  GetTokenActivity,
+  GetTokenData,
+} from "../types/generated/queries";
+import { queryIndexer } from "./general";
+import { generateTransaction } from "./transactionSubmission";
+import { MAX_U64_BIG_INT } from "../bcs/consts";
+import { CurrentTokenOwnershipsV2BoolExp, TokenActivitiesV2BoolExp } from "../types/generated/types";
+
+// TODO: Support properties when minting.
+export interface MintTokenOptions {
+  propertyKeys?: Array<string>;
+  propertyTypes?: Array<string>;
+  propertyValues?: Array<string>;
+}
+
+export async function mintTokenTransaction(args: {
+  aptosConfig: AptosConfig;
+  creator: Account;
+  collection: string;
+  description: string;
+  name: string;
+  uri: string;
+  options?: GenerateTransactionOptions;
+}): Promise<SingleSignerTransaction> {
+  const { aptosConfig, options, creator } = args;
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: creator.accountAddress.toString(),
+    data: {
+      function: "0x4::aptos_token::mint",
+      arguments: [
+        new MoveString(args.collection),
+        new MoveString(args.description),
+        new MoveString(args.name),
+        new MoveString(args.uri),
+        MoveVector.MoveString([]),
+        MoveVector.MoveString([]),
+        new MoveVector<MoveVector<U8>>([]),
+      ],
+    },
+    options,
+  });
+  return transaction as SingleSignerTransaction;
+}
+
+export async function getTokenData(args: {
+  aptosConfig: AptosConfig;
+  tokenAddress: HexInput;
+}): Promise<GetTokenDataResponse> {
+  const { aptosConfig, tokenAddress } = args;
+
+  const whereCondition: any = {
+    token_data_id: { _eq: Hex.fromHexInput(tokenAddress).toString() },
+  };
+
+  const graphqlQuery = {
+    query: GetTokenData,
+    variables: {
+      where_condition: whereCondition,
+    },
+  };
+
+  const data = await queryIndexer<GetTokenDataQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getTokenData",
+  });
+
+  return data.current_token_datas_v2[0];
+}
+
+export async function getCurrentTokenOwnership(args: {
+  aptosConfig: AptosConfig;
+  tokenAddress: HexInput;
+}): Promise<GetCurrentTokenOwnershipResponse> {
+  const { aptosConfig, tokenAddress } = args;
+
+  const whereCondition: CurrentTokenOwnershipsV2BoolExp = {
+    token_data_id: { _eq: Hex.fromHexInput(tokenAddress).toString() },
+  };
+
+  const graphqlQuery = {
+    query: GetCurrentTokenOwnership,
+    variables: {
+      where_condition: whereCondition,
+    },
+  };
+
+  const data = await queryIndexer<GetCurrentTokenOwnershipQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getCurrentTokenOwnership",
+  });
+
+  return data.current_token_ownerships_v2[0];
+}
+
+export async function getOwnedTokens(args: {
+  aptosConfig: AptosConfig;
+  ownerAddress: HexInput;
+  options?: {
+    pagination?: PaginationArgs;
+    orderBy?: OrderBy<GetTokenActivityResponse[0]>;
+  };
+}): Promise<GetOwnedTokensResponse> {
+  const { aptosConfig, ownerAddress, options } = args;
+
+  const whereCondition: CurrentTokenOwnershipsV2BoolExp = {
+    owner_address: { _eq: Hex.fromHexInput(ownerAddress).toString() },
+  };
+
+  const graphqlQuery = {
+    query: GetCurrentTokenOwnership,
+    variables: {
+      where_condition: whereCondition,
+      offset: options?.pagination?.offset,
+      limit: options?.pagination?.limit,
+      order_by: options?.orderBy,
+    },
+  };
+
+  const data = await queryIndexer<GetCurrentTokenOwnershipQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getOwnedTokens",
+  });
+
+  return data.current_token_ownerships_v2;
+}
+
+export async function getTokenActivity(args: {
+  aptosConfig: AptosConfig;
+  tokenAddress: HexInput;
+  options?: {
+    pagination?: PaginationArgs;
+    orderBy?: OrderBy<GetTokenActivityResponse[0]>;
+  };
+}): Promise<GetTokenActivityResponse> {
+  const { aptosConfig, tokenAddress, options } = args;
+
+  const whereCondition: TokenActivitiesV2BoolExp = {
+    token_data_id: { _eq: Hex.fromHexInput(tokenAddress).toString() },
+  };
+
+  const graphqlQuery = {
+    query: GetTokenActivity,
+    variables: {
+      where_condition: whereCondition,
+      offset: options?.pagination?.offset,
+      limit: options?.pagination?.limit,
+      order_by: options?.orderBy,
+    },
+  };
+
+  const data = await queryIndexer<GetTokenActivityQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getTokenActivity",
+  });
+
+  return data.token_activities_v2;
+}
+
+export interface CreateCollectionOptions {
+  maxSupply?: AnyNumber;
+  mutableDescription?: boolean;
+  mutableRoyalty?: boolean;
+  mutableURI?: boolean;
+  mutableTokenDescription?: boolean;
+  mutableTokenName?: boolean;
+  mutableTokenProperties?: boolean;
+  mutableTokenURI?: boolean;
+  tokensBurnableByCreator?: boolean;
+  tokensFreezableByCreator?: boolean;
+  royaltyNumerator?: number;
+  royaltyDenominator?: number;
+}
+
+export async function createCollectionTransaction(
+  args: {
+    aptosConfig: AptosConfig;
+    creator: Account;
+    description: string;
+    name: string;
+    uri: string;
+    options?: GenerateTransactionOptions;
+  } & CreateCollectionOptions,
+): Promise<SingleSignerTransaction> {
+  const { aptosConfig, options, creator } = args;
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: creator.accountAddress.toString(),
+    data: {
+      function: "0x4::aptos_token::create_collection",
+      arguments: [
+        // Do not change the order
+        new MoveString(args.description),
+        new U64(args.maxSupply ?? MAX_U64_BIG_INT),
+        new MoveString(args.name),
+        new MoveString(args.uri),
+        new Bool(args.mutableDescription ?? true),
+        new Bool(args.mutableRoyalty ?? true),
+        new Bool(args.mutableURI ?? true),
+        new Bool(args.mutableTokenDescription ?? true),
+        new Bool(args.mutableTokenName ?? true),
+        new Bool(args.mutableTokenProperties ?? true),
+        new Bool(args.mutableTokenURI ?? true),
+        new Bool(args.tokensBurnableByCreator ?? true),
+        new Bool(args.tokensFreezableByCreator ?? true),
+        new U64(args.royaltyNumerator ?? 0),
+        new U64(args.royaltyDenominator ?? 1),
+      ],
+    },
+    options,
+  });
+  return transaction as SingleSignerTransaction;
+}
+
+export async function getCollectionData(args: {
+  aptosConfig: AptosConfig;
+  creatorAddress: HexInput;
+  collectionName: string;
+  options?: {
+    tokenStandard?: TokenStandard;
+  };
+}): Promise<GetCollectionDataResponse> {
+  const { aptosConfig, creatorAddress, collectionName, options } = args;
+  const address = Hex.fromHexInput(creatorAddress).toString();
+
+  const whereCondition: any = {
+    collection_name: { _eq: collectionName },
+    creator_address: { _eq: address },
+  };
+
+  if (options?.tokenStandard) {
+    whereCondition.token_standard = { _eq: options?.tokenStandard ?? "v2" };
+  }
+
+  const graphqlQuery = {
+    query: GetCollectionData,
+    variables: {
+      where_condition: whereCondition,
+    },
+  };
+  const data = await queryIndexer<GetCollectionDataQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getCollectionData",
+  });
+
+  if (data.current_collections_v2.length === 0) {
+    throw Error("Collection not found");
+  }
+
+  return data.current_collections_v2[0];
+}
+
+export async function getCollectionId(args: {
+  aptosConfig: AptosConfig;
+  creatorAddress: HexInput;
+  collectionName: string;
+  options?: {
+    tokenStandard?: TokenStandard;
+  };
+}): Promise<string> {
+  return (await getCollectionData(args)).collection_id;
+}

package/src/internal/event.ts

@@ -0,0 +1,88 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/event}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * event namespace and without having a dependency cycle error.
+ */
+
+import { AptosConfig } from "../api/aptosConfig";
+import { AccountAddress } from "../core";
+import { AnyNumber, GetEventsResponse, HexInput, PaginationArgs, MoveResourceType, OrderBy } from "../types";
+import { GetEventsQuery } from "../types/generated/operations";
+import { GetEvents } from "../types/generated/queries";
+import { EventsBoolExp } from "../types/generated/types";
+import { queryIndexer } from "./general";
+
+export async function getAccountEventsByCreationNumber(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: HexInput;
+  creationNumber: AnyNumber;
+}): Promise<GetEventsResponse> {
+  const { accountAddress, aptosConfig, creationNumber } = args;
+  const address = AccountAddress.fromHexInput(accountAddress).toString();
+
+  const whereCondition: EventsBoolExp = {
+    account_address: { _eq: address },
+    creation_number: { _eq: creationNumber },
+  };
+
+  return getEvents({ aptosConfig, options: { where: whereCondition } });
+}
+
+export async function getAccountEventsByEventType(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: HexInput;
+  eventType: MoveResourceType;
+  options?: {
+    pagination?: PaginationArgs;
+    orderBy?: OrderBy<GetEventsResponse[0]>;
+  };
+}): Promise<GetEventsResponse> {
+  const { accountAddress, aptosConfig, eventType, options } = args;
+  const address = AccountAddress.fromHexInput(accountAddress).toString();
+
+  const whereCondition: EventsBoolExp = {
+    account_address: { _eq: address },
+    type: { _eq: eventType },
+  };
+
+  const customOptions = {
+    where: whereCondition,
+    pagination: options?.pagination,
+    orderBy: options?.orderBy,
+  };
+
+  return getEvents({ aptosConfig, options: customOptions });
+}
+
+export async function getEvents(args: {
+  aptosConfig: AptosConfig;
+  options?: {
+    where?: EventsBoolExp;
+    pagination?: PaginationArgs;
+    orderBy?: OrderBy<GetEventsResponse[0]>;
+  };
+}): Promise<GetEventsResponse> {
+  const { aptosConfig, options } = args;
+
+  const graphqlQuery = {
+    query: GetEvents,
+    variables: {
+      where_condition: options?.where,
+      offset: options?.pagination?.offset,
+      limit: options?.pagination?.limit,
+      order_by: options?.orderBy,
+    },
+  };
+
+  const data = await queryIndexer<GetEventsQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getEvents",
+  });
+
+  return data.events;
+}

package/src/internal/faucet.ts

@@ -0,0 +1,41 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/faucet}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * faucet namespace and without having a dependency cycle error.
+ */
+
+import { AptosConfig } from "../api/aptosConfig";
+import { postAptosFaucet } from "../client";
+import { AccountAddress } from "../core";
+import { HexInput } from "../types";
+import { DEFAULT_TXN_TIMEOUT_SEC } from "../utils/const";
+import { waitForTransaction } from "./transaction";
+
+export async function fundAccount(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: HexInput;
+  amount: number;
+  timeoutSecs?: number;
+}): Promise<string> {
+  const { aptosConfig, accountAddress, amount } = args;
+  const timeoutSecs = args.timeoutSecs ?? DEFAULT_TXN_TIMEOUT_SEC;
+  const { data } = await postAptosFaucet<any, { txn_hashes: Array<string> }>({
+    aptosConfig,
+    path: "fund",
+    body: {
+      address: AccountAddress.fromHexInput(accountAddress).toString(),
+      amount,
+    },
+    originMethod: "fundAccount",
+  });
+
+  const txnHash = data.txn_hashes[0];
+
+  await waitForTransaction({ aptosConfig, transactionHash: txnHash, options: { timeoutSecs } });
+
+  return txnHash;
+}

package/src/internal/fungibleAsset.ts

@@ -0,0 +1,114 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/fungible_asset}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * fungible_asset namespace and without having a dependency cycle error.
+ */
+
+import { AptosConfig } from "../api/aptosConfig";
+import {
+  GetCurrentFungibleAssetBalancesResponse,
+  GetFungibleAssetActivitiesResponse,
+  GetFungibleAssetMetadataResponse,
+  PaginationArgs,
+} from "../types";
+import { queryIndexer } from "./general";
+import {
+  GetCurrentFungibleAssetBalances,
+  GetFungibleAssetActivities,
+  GetFungibleAssetMetadata,
+} from "../types/generated/queries";
+import {
+  GetCurrentFungibleAssetBalancesQuery,
+  GetFungibleAssetActivitiesQuery,
+  GetFungibleAssetMetadataQuery,
+} from "../types/generated/operations";
+import {
+  CurrentFungibleAssetBalancesBoolExp,
+  FungibleAssetActivitiesBoolExp,
+  FungibleAssetMetadataBoolExp,
+} from "../types/generated/types";
+
+export async function getFungibleAssetMetadata(args: {
+  aptosConfig: AptosConfig;
+  options?: {
+    pagination?: PaginationArgs;
+    where?: FungibleAssetMetadataBoolExp;
+  };
+}): Promise<GetFungibleAssetMetadataResponse> {
+  const { aptosConfig, options } = args;
+
+  const graphqlQuery = {
+    query: GetFungibleAssetMetadata,
+    variables: {
+      where_condition: options?.where,
+      limit: options?.pagination?.limit,
+      offset: options?.pagination?.offset,
+    },
+  };
+
+  const data = await queryIndexer<GetFungibleAssetMetadataQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getFungibleAssetMetadata",
+  });
+
+  return data.fungible_asset_metadata;
+}
+
+export async function getFungibleAssetActivities(args: {
+  aptosConfig: AptosConfig;
+  options?: {
+    pagination?: PaginationArgs;
+    where?: FungibleAssetActivitiesBoolExp;
+  };
+}): Promise<GetFungibleAssetActivitiesResponse> {
+  const { aptosConfig, options } = args;
+
+  const graphqlQuery = {
+    query: GetFungibleAssetActivities,
+    variables: {
+      where_condition: options?.where,
+      limit: options?.pagination?.limit,
+      offset: options?.pagination?.offset,
+    },
+  };
+
+  const data = await queryIndexer<GetFungibleAssetActivitiesQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getFungibleAssetActivities",
+  });
+
+  return data.fungible_asset_activities;
+}
+
+export async function getCurrentFungibleAssetBalances(args: {
+  aptosConfig: AptosConfig;
+  options?: {
+    pagination?: PaginationArgs;
+    where?: CurrentFungibleAssetBalancesBoolExp;
+  };
+}): Promise<GetCurrentFungibleAssetBalancesResponse> {
+  const { aptosConfig, options } = args;
+
+  const graphqlQuery = {
+    query: GetCurrentFungibleAssetBalances,
+    variables: {
+      where_condition: options?.where,
+      limit: options?.pagination?.limit,
+      offset: options?.pagination?.offset,
+    },
+  };
+
+  const data = await queryIndexer<GetCurrentFungibleAssetBalancesQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getCurrentFungibleAssetBalances",
+  });
+
+  return data.current_fungible_asset_balances;
+}

package/src/internal/general.ts

@@ -0,0 +1,160 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/general}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * general namespace and without having a dependency cycle error.
+ */
+
+import { AptosConfig } from "../api/aptosConfig";
+import { getAptosFullNode, postAptosFullNode, postAptosIndexer } from "../client";
+import {
+  AnyNumber,
+  Block,
+  GetChainTopUserTransactionsResponse,
+  GetProcessorStatusResponse,
+  GraphqlQuery,
+  LedgerInfo,
+  LedgerVersion,
+  MoveValue,
+  TableItemRequest,
+  ViewRequest,
+  ViewRequestData,
+} from "../types";
+import { GetChainTopUserTransactionsQuery, GetProcessorStatusQuery } from "../types/generated/operations";
+import { GetChainTopUserTransactions, GetProcessorStatus } from "../types/generated/queries";
+
+export async function getLedgerInfo(args: { aptosConfig: AptosConfig }): Promise<LedgerInfo> {
+  const { aptosConfig } = args;
+  const { data } = await getAptosFullNode<{}, LedgerInfo>({
+    aptosConfig,
+    originMethod: "getLedgerInfo",
+    path: "",
+  });
+  return data;
+}
+
+export async function getBlockByVersion(args: {
+  aptosConfig: AptosConfig;
+  ledgerVersion: AnyNumber;
+  options?: { withTransactions?: boolean };
+}): Promise<Block> {
+  const { aptosConfig, ledgerVersion, options } = args;
+  const { data } = await getAptosFullNode<{}, Block>({
+    aptosConfig,
+    originMethod: "getBlockByVersion",
+    path: `blocks/by_version/${ledgerVersion}`,
+    params: { with_transactions: options?.withTransactions },
+  });
+  return data;
+}
+
+export async function getBlockByHeight(args: {
+  aptosConfig: AptosConfig;
+  blockHeight: AnyNumber;
+  options?: { withTransactions?: boolean };
+}): Promise<Block> {
+  const { aptosConfig, blockHeight, options } = args;
+  const { data } = await getAptosFullNode<{}, Block>({
+    aptosConfig,
+    originMethod: "getBlockByHeight",
+    path: `blocks/by_height/${blockHeight}`,
+    params: { with_transactions: options?.withTransactions },
+  });
+  return data;
+}
+
+export async function getTableItem(args: {
+  aptosConfig: AptosConfig;
+  handle: string;
+  data: TableItemRequest;
+  options?: LedgerVersion;
+}): Promise<any> {
+  const { aptosConfig, handle, data, options } = args;
+  const response = await postAptosFullNode<TableItemRequest, any>({
+    aptosConfig,
+    originMethod: "getTableItem",
+    path: `tables/${handle}/item`,
+    params: { ledger_version: options?.ledgerVersion },
+    body: data,
+  });
+  return response.data;
+}
+
+export async function view(args: {
+  aptosConfig: AptosConfig;
+  payload: ViewRequestData;
+  options?: LedgerVersion;
+}): Promise<MoveValue[]> {
+  const { aptosConfig, payload, options } = args;
+  const { data } = await postAptosFullNode<ViewRequest, MoveValue[]>({
+    aptosConfig,
+    originMethod: "view",
+    path: "view",
+    params: { ledger_version: options?.ledgerVersion },
+    body: {
+      function: payload.function,
+      type_arguments: payload.typeArguments ?? [],
+      arguments: payload.arguments ?? [],
+    },
+  });
+  return data;
+}
+
+export async function getChainTopUserTransactions(args: {
+  aptosConfig: AptosConfig;
+  limit: number;
+}): Promise<GetChainTopUserTransactionsResponse> {
+  const { aptosConfig, limit } = args;
+  const graphqlQuery = {
+    query: GetChainTopUserTransactions,
+    variables: { limit },
+  };
+
+  const data = await queryIndexer<GetChainTopUserTransactionsQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getChainTopUserTransactions",
+  });
+
+  return data.user_transactions;
+}
+
+export async function queryIndexer<T>(args: {
+  aptosConfig: AptosConfig;
+  query: GraphqlQuery;
+  originMethod?: string;
+}): Promise<T> {
+  const { aptosConfig, query, originMethod } = args;
+  const { data } = await postAptosIndexer<GraphqlQuery, T>({
+    aptosConfig,
+    originMethod: originMethod ?? "queryIndexer",
+    path: "",
+    body: query,
+    overrides: { WITH_CREDENTIALS: false },
+  });
+  return data;
+}
+
+export async function getProcessorStatuses(args: { aptosConfig: AptosConfig }): Promise<GetProcessorStatusResponse> {
+  const { aptosConfig } = args;
+
+  const graphqlQuery = {
+    query: GetProcessorStatus,
+  };
+
+  const data = await queryIndexer<GetProcessorStatusQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getProcessorStatuses",
+  });
+
+  return data.processor_status;
+}
+
+export async function getIndexerLastSuccessVersion(args: { aptosConfig: AptosConfig }): Promise<number> {
+  const response = await getProcessorStatuses({ aptosConfig: args.aptosConfig });
+  return response[0].last_success_version;
+}