@moveindustries/ts-sdk 5.1.4

package/src/internal/faucet.ts

@@ -0,0 +1,71 @@
+// Copyright © Move Industries
+// 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.
+ * @group Implementation
+ */
+
+import { MovementConfig } from "../api/movementConfig";
+import { postAptosFaucet } from "../client";
+import { AccountAddress, AccountAddressInput } from "../core";
+import { TransactionResponseType, UserTransactionResponse, WaitForTransactionOptions } from "../types";
+import { DEFAULT_TXN_TIMEOUT_SEC } from "../utils/const";
+import { waitForTransaction } from "./transaction";
+
+/**
+ * Funds an account with a specified amount of tokens from the Movement faucet.
+ * This function is useful for quickly providing a new or existing account with tokens to facilitate transactions.
+ *
+ * @param args - The arguments for funding the account.
+ * @param args.movementConfig - The configuration settings for connecting to the Movement network.
+ * @param args.accountAddress - The address of the account to be funded.
+ * @param args.amount - The amount of tokens to fund the account with.
+ * @param args.options - Optional parameters for the transaction.
+ * @param args.options.timeoutSecs - The maximum time to wait for the transaction to complete, in seconds.
+ * @param args.options.checkSuccess - A flag indicating whether to check if the transaction was successful.
+ *
+ * @throws Error if the transaction does not return a user transaction type.
+ * @group Implementation
+ */
+export async function fundAccount(args: {
+  movementConfig: MovementConfig;
+  accountAddress: AccountAddressInput;
+  amount: number;
+  options?: WaitForTransactionOptions;
+}): Promise<UserTransactionResponse> {
+  const { movementConfig, accountAddress, amount, options } = args;
+  const timeout = options?.timeoutSecs || DEFAULT_TXN_TIMEOUT_SEC;
+  // Movement faucet uses /mint endpoint with query params
+  const { data } = await postAptosFaucet<any, Array<string>>({
+    movementConfig,
+    path: "mint",
+    params: {
+      address: AccountAddress.from(accountAddress).toString(),
+      amount,
+    },
+    originMethod: "fundAccount",
+  });
+
+  // Movement faucet returns array of transaction hashes directly
+  const txnHash = data[0];
+
+  const res = await waitForTransaction({
+    movementConfig,
+    transactionHash: txnHash,
+    options: {
+      timeoutSecs: timeout,
+      checkSuccess: options?.checkSuccess,
+    },
+  });
+
+  // Response is always User transaction for a user submitted transaction
+  if (res.type === TransactionResponseType.User) {
+    return res;
+  }
+
+  throw new Error(`Unexpected transaction received for fund account: ${res.type}`);
+}

package/src/internal/fungibleAsset.ts

@@ -0,0 +1,233 @@
+// Copyright © Move Industries
+// 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.
+ * @group Implementation
+ */
+
+import { Account } from "../account";
+import { MovementConfig } from "../api/movementConfig";
+import { AccountAddressInput } from "../core";
+import {
+  EntryFunctionABI,
+  InputGenerateTransactionOptions,
+  parseTypeTag,
+  TypeTagAddress,
+  TypeTagU64,
+} from "../transactions";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
+import {
+  AnyNumber,
+  GetCurrentFungibleAssetBalancesResponse,
+  GetFungibleAssetActivitiesResponse,
+  GetFungibleAssetMetadataResponse,
+  PaginationArgs,
+  WhereArg,
+} from "../types";
+import {
+  GetCurrentFungibleAssetBalancesQuery,
+  GetFungibleAssetActivitiesQuery,
+  GetFungibleAssetMetadataQuery,
+} from "../types/generated/operations";
+import {
+  GetCurrentFungibleAssetBalances,
+  GetFungibleAssetActivities,
+  GetFungibleAssetMetadata,
+} from "../types/generated/queries";
+import {
+  CurrentFungibleAssetBalancesBoolExp,
+  FungibleAssetActivitiesBoolExp,
+  FungibleAssetMetadataBoolExp,
+} from "../types/generated/types";
+import { queryIndexer } from "./general";
+import { generateTransaction } from "./transactionSubmission";
+
+/**
+ * Retrieves metadata for fungible assets based on specified criteria.
+ * This function allows you to filter and paginate through fungible asset metadata.
+ *
+ * @param args - The arguments for the function.
+ * @param args.movementConfig - The configuration for Movement.
+ * @param [args.options] - Optional parameters for pagination and filtering.
+ * @param [args.options.limit] - The maximum number of results to return.
+ * @param [args.options.offset] - The number of results to skip before starting to collect the result set.
+ * @param [args.options.where] - Conditions to filter the results.
+ * @group Implementation
+ */
+export async function getFungibleAssetMetadata(args: {
+  movementConfig: MovementConfig;
+  options?: PaginationArgs & WhereArg<FungibleAssetMetadataBoolExp>;
+}): Promise<GetFungibleAssetMetadataResponse> {
+  const { movementConfig, options } = args;
+
+  const graphqlQuery = {
+    query: GetFungibleAssetMetadata,
+    variables: {
+      where_condition: options?.where,
+      limit: options?.limit,
+      offset: options?.offset,
+    },
+  };
+
+  const data = await queryIndexer<GetFungibleAssetMetadataQuery>({
+    movementConfig,
+    query: graphqlQuery,
+    originMethod: "getFungibleAssetMetadata",
+  });
+
+  return data.fungible_asset_metadata;
+}
+
+/**
+ * Retrieves the activities associated with fungible assets.
+ * This function allows you to filter and paginate through the activities based on specified conditions.
+ *
+ * @param args - The arguments for retrieving fungible asset activities.
+ * @param args.movementConfig - The configuration settings for Movement.
+ * @param [args.options] - Optional parameters for pagination and filtering.
+ * @param [args.options.limit] - The maximum number of activities to retrieve.
+ * @param [args.options.offset] - The number of activities to skip before starting to collect the result set.
+ * @param [args.options.where] - Conditions to filter the activities.
+ * @returns A promise that resolves to an array of fungible asset activities.
+ * @group Implementation
+ */
+export async function getFungibleAssetActivities(args: {
+  movementConfig: MovementConfig;
+  options?: PaginationArgs & WhereArg<FungibleAssetActivitiesBoolExp>;
+}): Promise<GetFungibleAssetActivitiesResponse> {
+  const { movementConfig, options } = args;
+
+  const graphqlQuery = {
+    query: GetFungibleAssetActivities,
+    variables: {
+      where_condition: options?.where,
+      limit: options?.limit,
+      offset: options?.offset,
+    },
+  };
+
+  const data = await queryIndexer<GetFungibleAssetActivitiesQuery>({
+    movementConfig,
+    query: graphqlQuery,
+    originMethod: "getFungibleAssetActivities",
+  });
+
+  return data.fungible_asset_activities;
+}
+
+/**
+ * Retrieves the current balances of fungible assets for a specified configuration.
+ *
+ * @param args - The arguments for retrieving fungible asset balances.
+ * @param args.movementConfig - The configuration settings for Movement.
+ * @param args.options - Optional parameters for pagination and filtering.
+ * @param args.options.limit - The maximum number of results to return.
+ * @param args.options.offset - The number of results to skip before starting to collect the results.
+ * @param args.options.where - Conditions to filter the results based on specific criteria.
+ * @returns The current balances of fungible assets.
+ * @group Implementation
+ */
+export async function getCurrentFungibleAssetBalances(args: {
+  movementConfig: MovementConfig;
+  options?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
+}): Promise<GetCurrentFungibleAssetBalancesResponse> {
+  const { movementConfig, options } = args;
+
+  const graphqlQuery = {
+    query: GetCurrentFungibleAssetBalances,
+    variables: {
+      where_condition: options?.where,
+      limit: options?.limit,
+      offset: options?.offset,
+    },
+  };
+
+  const data = await queryIndexer<GetCurrentFungibleAssetBalancesQuery>({
+    movementConfig,
+    query: graphqlQuery,
+    originMethod: "getCurrentFungibleAssetBalances",
+  });
+
+  return data.current_fungible_asset_balances;
+}
+
+const faTransferAbi: EntryFunctionABI = {
+  typeParameters: [{ constraints: [] }],
+  parameters: [parseTypeTag("0x1::object::Object"), new TypeTagAddress(), new TypeTagU64()],
+};
+
+/**
+ * Transfers a specified amount of a fungible asset from the sender to the recipient.
+ * This function helps facilitate the transfer of digital assets between accounts on the Movement blockchain.
+ *
+ * @param args - The parameters for the transfer operation.
+ * @param args.movementConfig - The configuration settings for the Movement network.
+ * @param args.sender - The account initiating the transfer.
+ * @param args.fungibleAssetMetadataAddress - The address of the fungible asset's metadata.
+ * @param args.recipient - The address of the account receiving the asset.
+ * @param args.amount - The amount of the fungible asset to transfer.
+ * @param args.options - Optional settings for generating the transaction.
+ * @group Implementation
+ */
+export async function transferFungibleAsset(args: {
+  movementConfig: MovementConfig;
+  sender: Account;
+  fungibleAssetMetadataAddress: AccountAddressInput;
+  recipient: AccountAddressInput;
+  amount: AnyNumber;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SimpleTransaction> {
+  const { movementConfig, sender, fungibleAssetMetadataAddress, recipient, amount, options } = args;
+  return generateTransaction({
+    movementConfig,
+    sender: sender.accountAddress,
+    data: {
+      function: "0x1::primary_fungible_store::transfer",
+      typeArguments: ["0x1::fungible_asset::Metadata"],
+      functionArguments: [fungibleAssetMetadataAddress, recipient, amount],
+      abi: faTransferAbi,
+    },
+    options,
+  });
+}
+
+/**
+ * Transfers a specified amount of a fungible asset from any (primary or secondary) fungible store to any (primary or secondary) fungible store.
+ * This function helps facilitate the transfer of digital assets between fungible stores on the Movement blockchain.
+ *
+ * @param args - The parameters for the transfer operation.
+ * @param args.movementConfig - The configuration settings for the Movement network.
+ * @param args.sender - The account initiating the transfer.
+ * @param args.fromStore - The address of the fungible store initiating the transfer.
+ * @param args.toStore - The address of the fungible store receiving the asset.
+ * @param args.amount - The amount of the fungible asset to transfer. Must be a positive number.
+ * @param args.options - Optional settings for generating the transaction.
+ * @returns A SimpleTransaction that can be submitted to the blockchain.
+ * @throws Error if the transaction generation fails or if the input parameters are invalid.
+ * @group Implementation
+ */
+export async function transferFungibleAssetBetweenStores(args: {
+  movementConfig: MovementConfig;
+  sender: Account;
+  fromStore: AccountAddressInput;
+  toStore: AccountAddressInput;
+  amount: AnyNumber;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SimpleTransaction> {
+  const { movementConfig, sender, fromStore, toStore, amount, options } = args;
+  return generateTransaction({
+    movementConfig,
+    sender: sender.accountAddress,
+    data: {
+      function: "0x1::dispatchable_fungible_asset::transfer",
+      typeArguments: ["0x1::fungible_asset::FungibleStore"],
+      functionArguments: [fromStore, toStore, amount],
+      abi: faTransferAbi,
+    },
+    options,
+  });
+}

package/src/internal/general.ts

@@ -0,0 +1,161 @@
+// Copyright © Move Industries
+// 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.
+ * @group Implementation
+ */
+
+import { MovementConfig } from "../api/movementConfig";
+import { getAptosFullNode, postAptosIndexer } from "../client";
+import { GetChainTopUserTransactionsResponse, GetProcessorStatusResponse, GraphqlQuery, LedgerInfo } from "../types";
+import { GetChainTopUserTransactionsQuery, GetProcessorStatusQuery } from "../types/generated/operations";
+import { GetChainTopUserTransactions, GetProcessorStatus } from "../types/generated/queries";
+import { ProcessorType } from "../utils/const";
+
+/**
+ * Retrieves information about the current ledger.
+ *
+ * @param args - The arguments for retrieving ledger information.
+ * @param args.movementConfig - The configuration object for connecting to the Movement network.
+ * @group Implementation
+ */
+export async function getLedgerInfo(args: { movementConfig: MovementConfig }): Promise<LedgerInfo> {
+  const { movementConfig } = args;
+  const { data } = await getAptosFullNode<{}, LedgerInfo>({
+    movementConfig,
+    originMethod: "getLedgerInfo",
+    path: "",
+  });
+  return data;
+}
+
+/**
+ * Retrieves the top user transactions for a specific blockchain chain.
+ *
+ * @param args - The arguments for the function.
+ * @param args.movementConfig - The configuration object for Movement.
+ * @param args.limit - The maximum number of transactions to retrieve.
+ * @returns An array of user transactions.
+ * @group Implementation
+ */
+export async function getChainTopUserTransactions(args: {
+  movementConfig: MovementConfig;
+  limit: number;
+}): Promise<GetChainTopUserTransactionsResponse> {
+  const { movementConfig, limit } = args;
+  const graphqlQuery = {
+    query: GetChainTopUserTransactions,
+    variables: { limit },
+  };
+
+  const data = await queryIndexer<GetChainTopUserTransactionsQuery>({
+    movementConfig,
+    query: graphqlQuery,
+    originMethod: "getChainTopUserTransactions",
+  });
+
+  return data.user_transactions;
+}
+
+/**
+ * Executes a GraphQL query against the Movement indexer and retrieves the resulting data.
+ *
+ * @param args - The arguments for the query.
+ * @param args.movementConfig - The configuration settings for the Movement client.
+ * @param args.query - The GraphQL query to be executed.
+ * @param args.originMethod - An optional string to specify the origin method for tracking purposes.
+ * @returns The data returned from the query execution.
+ * @group Implementation
+ */
+export async function queryIndexer<T extends {}>(args: {
+  movementConfig: MovementConfig;
+  query: GraphqlQuery;
+  originMethod?: string;
+}): Promise<T> {
+  const { movementConfig, query, originMethod } = args;
+  const { data } = await postAptosIndexer<GraphqlQuery, T>({
+    movementConfig,
+    originMethod: originMethod ?? "queryIndexer",
+    path: "",
+    body: query,
+    overrides: { WITH_CREDENTIALS: false },
+  });
+  return data;
+}
+
+/**
+ * Retrieves the current statuses of processors.
+ *
+ * @param args - The arguments for the function.
+ * @param args.movementConfig - The configuration object for Movement.
+ * @returns The statuses of the processors.
+ * @group Implementation
+ */
+export async function getProcessorStatuses(args: { movementConfig: MovementConfig }): Promise<GetProcessorStatusResponse> {
+  const { movementConfig } = args;
+
+  const graphqlQuery = {
+    query: GetProcessorStatus,
+  };
+
+  const data = await queryIndexer<GetProcessorStatusQuery>({
+    movementConfig,
+    query: graphqlQuery,
+    originMethod: "getProcessorStatuses",
+  });
+
+  return data.processor_status;
+}
+
+/**
+ * Retrieves the last success version from the indexer.
+ *
+ * @param args - The arguments for the function.
+ * @param args.movementConfig - The configuration object for Movement.
+ * @returns The last success version as a BigInt.
+ * @group Implementation
+ */
+export async function getIndexerLastSuccessVersion(args: { movementConfig: MovementConfig }): Promise<bigint> {
+  const response = await getProcessorStatuses({ movementConfig: args.movementConfig });
+  return BigInt(response[0].last_success_version);
+}
+
+/**
+ * Retrieves the status of a specified processor in the Movement network.
+ * This function allows you to check the current operational status of a processor, which can be useful for monitoring and troubleshooting.
+ *
+ * @param args - The arguments for the function.
+ * @param args.movementConfig - The configuration object for connecting to the Movement network.
+ * @param args.processorType - The type of processor whose status you want to retrieve.
+ * @returns The status of the specified processor.
+ * @group Implementation
+ */
+export async function getProcessorStatus(args: {
+  movementConfig: MovementConfig;
+  processorType: ProcessorType;
+}): Promise<GetProcessorStatusResponse[0]> {
+  const { movementConfig, processorType } = args;
+
+  const whereCondition: { processor: { _eq: string } } = {
+    processor: { _eq: processorType },
+  };
+
+  const graphqlQuery = {
+    query: GetProcessorStatus,
+    variables: {
+      where_condition: whereCondition,
+    },
+  };
+
+  const data = await queryIndexer<GetProcessorStatusQuery>({
+    movementConfig,
+    query: graphqlQuery,
+    originMethod: "getProcessorStatus",
+  });
+
+  return data.processor_status[0];
+}