@aptos-labs/ts-sdk 0.0.7 → 1.0.0

package/src/api/digitalAsset.ts

@@ -2,17 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {
+  AnyNumber,
   GetCollectionDataResponse,
   GetCurrentTokenOwnershipResponse,
   GetOwnedTokensResponse,
   GetTokenActivityResponse,
   GetTokenDataResponse,
-  OrderBy,
+  MoveStructId,
+  OrderByArg,
   PaginationArgs,
   TokenStandard,
+  TokenStandardArg,
 } from "../types";
-import { AptosConfig } from "./aptosConfig";
-import { Account, AccountAddressInput } from "../core";
+import { Account, AccountAddress, AccountAddressInput } from "../core";
 import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
 import {
   CreateCollectionOptions,
@@ -24,17 +26,17 @@ import {
   getTokenActivity,
   getTokenData,
   mintTokenTransaction,
+  transferDigitalAsset,
 } from "../internal/digitalAsset";
+import { ProcessorType } from "../utils/const";
+import { AptosConfig } from "./aptosConfig";
+import { waitForIndexerOnVersion } from "./utils";
 
 /**
  * A class to query all `DigitalAsset` related queries on Aptos.
  */
 export class DigitalAsset {
-  readonly config: AptosConfig;
-
-  constructor(config: AptosConfig) {
-    this.config = config;
-  }
+  constructor(readonly config: AptosConfig) {}
 
   /**
    * Creates a new collection within the specified account
@@ -81,16 +83,21 @@ export class DigitalAsset {
    *
    * @param args.creatorAddress the address of the collection's creator
    * @param args.collectionName the name of the collection
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @param args.options.tokenStandard the token standard to query
    * @returns GetCollectionDataResponse response type
    */
   async getCollectionData(args: {
     creatorAddress: AccountAddressInput;
     collectionName: string;
-    options?: {
-      tokenStandard?: TokenStandard;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: TokenStandardArg;
   }): Promise<GetCollectionDataResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: getTokenProcessorTypes(args.options?.tokenStandard),
+    });
     return getCollectionData({ aptosConfig: this.config, ...args });
   }
 
@@ -102,16 +109,21 @@ export class DigitalAsset {
    *
    * @param args.creatorAddress the address of the collection's creator
    * @param args.collectionName the name of the collection
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @param args.options.tokenStandard the token standard to query
    * @returns the collection id
    */
   async getCollectionId(args: {
     creatorAddress: AccountAddressInput;
     collectionName: string;
-    options?: {
-      tokenStandard?: TokenStandard;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: TokenStandardArg;
   }): Promise<string> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: getTokenProcessorTypes(args.options?.tokenStandard),
+    });
     return getCollectionId({ aptosConfig: this.config, ...args });
   }
 
@@ -141,9 +153,19 @@ export class DigitalAsset {
    * Gets token data given the address of a token.
    *
    * @param args.tokenAddress The address of the token
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns GetTokenDataResponse containing relevant data to the token.
    */
-  async getTokenData(args: { tokenAddress: AccountAddressInput }): Promise<GetTokenDataResponse> {
+  async getTokenData(args: {
+    tokenAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
+  }): Promise<GetTokenDataResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      // TODO(greg): Should take in a consistent input for token queries
+      processorTypes: getTokenProcessorTypes(undefined),
+    });
     return getTokenData({ aptosConfig: this.config, ...args });
   }
 
@@ -151,11 +173,19 @@ export class DigitalAsset {
    * Gets token ownership data given the address of a token.
    *
    * @param args.tokenAddress The address of the token
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns GetCurrentTokenOwnershipResponse containing relevant ownership data of the token.
    */
   async getCurrentTokenOwnership(args: {
     tokenAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
   }): Promise<GetCurrentTokenOwnershipResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      // TODO(greg): Should take in a consistent input for token queries
+      processorTypes: getTokenProcessorTypes(undefined),
+    });
     return getCurrentTokenOwnership({ aptosConfig: this.config, ...args });
   }
 
@@ -163,15 +193,20 @@ export class DigitalAsset {
    * Gets the tokens that the given address owns.
    *
    * @param args.ownerAddress The address of the owner
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns GetOwnedTokensResponse containing ownership data of the tokens belonging to the ownerAddresss.
    */
   async getOwnedTokens(args: {
     ownerAddress: AccountAddressInput;
-    options?: {
-      pagination?: PaginationArgs;
-      orderBy?: OrderBy<GetOwnedTokensResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: PaginationArgs & OrderByArg<GetOwnedTokensResponse[0]>;
   }): Promise<GetOwnedTokensResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      // TODO(greg): Should take in a consistent input for token queries
+      processorTypes: getTokenProcessorTypes(undefined),
+    });
     return getOwnedTokens({ aptosConfig: this.config, ...args });
   }
 
@@ -179,15 +214,55 @@ export class DigitalAsset {
    * Gets the activity data given the address of a token.
    *
    * @param args.tokenAddress The address of the token
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns GetTokenActivityResponse containing relevant activity data to the token.
    */
   async getTokenActivity(args: {
     tokenAddress: AccountAddressInput;
-    options?: {
-      pagination?: PaginationArgs;
-      orderBy?: OrderBy<GetTokenActivityResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: PaginationArgs & OrderByArg<GetTokenActivityResponse[0]>;
   }): Promise<GetTokenActivityResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      // TODO(greg): Should take in a consistent input for token queries
+      processorTypes: getTokenProcessorTypes(undefined),
+    });
     return getTokenActivity({ aptosConfig: this.config, ...args });
   }
+
+  /**
+   * Transfer a digital asset (non fungible token) ownership.
+   *
+   * We can transfer a digital asset only when the digital asset is not frozen
+   * (i.e. owner transfer is not disabled such as for soul bound tokens)
+   *
+   * @param args.sender The sender account of the current digital asset owner
+   * @param args.digitalAssetAddress The digital asset address
+   * @param args.recipient The recipient account address
+   * @param args.digitalAssetType optional. The digital asset type, default to "0x4::token::Token"
+   *
+   * @returns A SingleSignerTransaction that can be simulated or submitted to chain
+   */
+  async transferDigitalAsset(args: {
+    sender: Account;
+    digitalAssetAddress: AccountAddressInput;
+    recipient: AccountAddress;
+    digitalAssetType?: MoveStructId;
+    options?: InputGenerateTransactionOptions;
+  }): Promise<SingleSignerTransaction> {
+    return transferDigitalAsset({ aptosConfig: this.config, ...args });
+  }
+}
+
+function getTokenProcessorTypes(tokenStandard?: TokenStandard) {
+  switch (tokenStandard) {
+    case "v1":
+      return [ProcessorType.TOKEN_PROCESSOR];
+    case "v2":
+      return [ProcessorType.TOKEN_V2_PROCESSOR];
+    default:
+      // If it's something we don't recognize, or undefined, just do both
+      return [ProcessorType.TOKEN_PROCESSOR, ProcessorType.TOKEN_V2_PROCESSOR];
+  }
 }

package/src/api/event.ts

@@ -1,34 +1,39 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AptosConfig } from "./aptosConfig";
 import { getAccountEventsByCreationNumber, getAccountEventsByEventType, getEvents } from "../internal/event";
-import { AnyNumber, GetEventsResponse, MoveStructId, OrderBy, PaginationArgs } from "../types";
+import { AnyNumber, GetEventsResponse, MoveStructId, OrderByArg, PaginationArgs, WhereArg } from "../types";
 import { EventsBoolExp } from "../types/generated/types";
 import { AccountAddressInput } from "../core";
+import { ProcessorType } from "../utils/const";
+import { AptosConfig } from "./aptosConfig";
+import { waitForIndexerOnVersion } from "./utils";
 
 /**
  * A class to query all `Event` Aptos related queries
  */
 export class Event {
-  readonly config: AptosConfig;
-
-  constructor(config: AptosConfig) {
-    this.config = config;
-  }
+  constructor(readonly config: AptosConfig) {}
 
   /**
    * Get events by creation number and an account address
    *
    * @param args.accountAddress - The account address
    * @param args.creationNumber - The event creation number
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    *
    * @returns Promise<GetEventsResponse>
    */
   async getAccountEventsByCreationNumber(args: {
     accountAddress: AccountAddressInput;
     creationNumber: AnyNumber;
+    minimumLedgerVersion?: AnyNumber;
   }): Promise<GetEventsResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.EVENTS_PROCESSOR],
+    });
     return getAccountEventsByCreationNumber({ aptosConfig: this.config, ...args });
   }
 
@@ -37,17 +42,21 @@ export class Event {
    *
    * @param args.accountAddress - The account address
    * @param args.eventType - The event type
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    *
    * @returns Promise<GetEventsResponse>
    */
   async getAccountEventsByEventType(args: {
     accountAddress: AccountAddressInput;
     eventType: MoveStructId;
-    options?: {
-      pagination?: PaginationArgs;
-      orderBy?: OrderBy<GetEventsResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;
   }): Promise<GetEventsResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.EVENTS_PROCESSOR],
+    });
     return getAccountEventsByEventType({ aptosConfig: this.config, ...args });
   }
 
@@ -55,7 +64,7 @@ export class Event {
    * Get all events
    *
    * An optional `where` can be passed in to filter out the response.
-   *
+   *@param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @example
    * ```
    * { where:
@@ -68,12 +77,14 @@ export class Event {
    * @returns GetEventsQuery response type
    */
   async getEvents(args?: {
-    options?: {
-      where?: EventsBoolExp;
-      pagination?: PaginationArgs;
-      orderBy?: OrderBy<GetEventsResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: PaginationArgs & OrderByArg<GetEventsResponse[0]> & WhereArg<EventsBoolExp>;
   }): Promise<GetEventsResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.EVENTS_PROCESSOR],
+    });
     return getEvents({ aptosConfig: this.config, ...args });
   }
 }

package/src/api/faucet.ts

@@ -1,20 +1,17 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AptosConfig } from "./aptosConfig";
 import { fundAccount } from "../internal/faucet";
-import { WaitForTransactionOptions } from "../types";
+import { UserTransactionResponse, WaitForTransactionOptions } from "../types";
 import { AccountAddressInput } from "../core";
+import { AptosConfig } from "./aptosConfig";
+import { waitForIndexer } from "../internal/transaction";
 
 /**
  * A class to query all `Faucet` related queries on Aptos.
  */
 export class Faucet {
-  readonly config: AptosConfig;
-
-  constructor(config: AptosConfig) {
-    this.config = config;
-  }
+  constructor(readonly config: AptosConfig) {}
 
   /**
    * This creates an account if it does not exist and mints the specified amount of
@@ -29,7 +26,13 @@ export class Faucet {
     accountAddress: AccountAddressInput;
     amount: number;
     options?: WaitForTransactionOptions;
-  }): Promise<string> {
-    return fundAccount({ aptosConfig: this.config, ...args });
+  }): Promise<UserTransactionResponse> {
+    const fundTxn = await fundAccount({ aptosConfig: this.config, ...args });
+
+    if (args.options?.waitForIndexer !== false) {
+      await waitForIndexer({ aptosConfig: this.config, minimumLedgerVersion: BigInt(fundTxn.version) });
+    }
+
+    return fundTxn;
   }
 }

package/src/api/fungibleAsset.ts

@@ -2,68 +2,82 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {
+  AnyNumber,
   GetCurrentFungibleAssetBalancesResponse,
   GetFungibleAssetActivitiesResponse,
   GetFungibleAssetMetadataResponse,
   PaginationArgs,
+  WhereArg,
 } from "../types";
-import { AptosConfig } from "./aptosConfig";
 import {
   getCurrentFungibleAssetBalances,
   getFungibleAssetActivities,
   getFungibleAssetMetadata,
+  transferFungibleAsset,
 } from "../internal/fungibleAsset";
 import {
   CurrentFungibleAssetBalancesBoolExp,
   FungibleAssetActivitiesBoolExp,
   FungibleAssetMetadataBoolExp,
 } from "../types/generated/types";
+import { ProcessorType } from "../utils/const";
+import { AptosConfig } from "./aptosConfig";
+import { waitForIndexerOnVersion } from "./utils";
+import { Account, AccountAddress } from "../core";
+import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions";
 
 /**
  * A class to query all `FungibleAsset` related queries on Aptos.
  */
 export class FungibleAsset {
-  readonly config: AptosConfig;
-
-  constructor(config: AptosConfig) {
-    this.config = config;
-  }
+  constructor(readonly config: AptosConfig) {}
 
   /**
-   * Queries the current fungible asset metadata.
+   * Queries all fungible asset metadata.
    *
-   * This query returns the fungible asset metadata for all fungible assets.
-   * It can be filtered by creator address and asset type.
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    *
-   * @returns getFungibleAssetMetadata A list of fungible asset metadata
+   * @returns A list of fungible asset metadata
    */
   async getFungibleAssetMetadata(args?: {
-    options?: {
-      pagination?: PaginationArgs;
-      where?: FungibleAssetMetadataBoolExp;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: PaginationArgs & WhereArg<FungibleAssetMetadataBoolExp>;
   }): Promise<GetFungibleAssetMetadataResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.FUNGIBLE_ASSET_PROCESSOR],
+    });
     return getFungibleAssetMetadata({ aptosConfig: this.config, ...args });
   }
 
   /**
-   * Queries the current specific fungible asset metadata
+   * Queries a fungible asset metadata
    *
    * This query returns the fungible asset metadata for a specific fungible asset.
    *
-   * @param assetType The asset type of the fungible asset.
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+   * @param args.assetType The asset type of the fungible asset.
    * e.g
    * "0x1::aptos_coin::AptosCoin" for Aptos Coin
    * "0xc2948283c2ce03aafbb294821de7ee684b06116bb378ab614fa2de07a99355a8" - address format if this is fungible asset
    *
-   * @returns getFungibleAssetMetadata A fungible asset metadata item
+   * @returns A fungible asset metadata item
    */
-  async getFungibleAssetMetadataByAssetType(assetType: string): Promise<GetFungibleAssetMetadataResponse[0]> {
+  async getFungibleAssetMetadataByAssetType(args: {
+    assetType: string;
+    minimumLedgerVersion?: AnyNumber;
+  }): Promise<GetFungibleAssetMetadataResponse[0]> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.FUNGIBLE_ASSET_PROCESSOR],
+    });
     const data = await getFungibleAssetMetadata({
       aptosConfig: this.config,
       options: {
         where: {
-          asset_type: { _eq: assetType },
+          asset_type: { _eq: args.assetType },
         },
       },
     });
@@ -72,36 +86,63 @@ export class FungibleAsset {
   }
 
   /**
-   * Queries the fungible asset activities
+   * Queries all fungible asset activities
    *
-   * This query returns the fungible asset activities.
-   * It can be filtered by owner address, asset type, and type.
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    *
-   * @returns GetFungibleAssetActivitiesResponse A list of fungible asset metadata
+   * @returns A list of fungible asset metadata
    */
   async getFungibleAssetActivities(args?: {
-    options?: {
-      pagination?: PaginationArgs;
-      where?: FungibleAssetActivitiesBoolExp;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: PaginationArgs & WhereArg<FungibleAssetActivitiesBoolExp>;
   }): Promise<GetFungibleAssetActivitiesResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.FUNGIBLE_ASSET_PROCESSOR],
+    });
     return getFungibleAssetActivities({ aptosConfig: this.config, ...args });
   }
 
   /**
-   * Queries the fungible asset balance
+   * Queries all fungible asset balances
    *
-   * This query returns the fungible asset balance.
-   * It can be filtered by owner address, and asset type
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    *
-   * @returns GetCurrentFungibleAssetBalancesResponse A list of fungible asset metadata
+   * @returns A list of fungible asset metadata
    */
   async getCurrentFungibleAssetBalances(args?: {
-    options?: {
-      pagination?: PaginationArgs;
-      where?: CurrentFungibleAssetBalancesBoolExp;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
   }): Promise<GetCurrentFungibleAssetBalancesResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.FUNGIBLE_ASSET_PROCESSOR],
+    });
     return getCurrentFungibleAssetBalances({ aptosConfig: this.config, ...args });
   }
+
+  /**
+   *  Transfer `amount` of fungible asset from sender's primary store to recipient's primary store.
+   *
+   * Use this method to transfer any fungible asset including fungible token.
+   *
+   * @param sender The sender account
+   * @param fungibleAssetMetadataAddress The fungible asset account address.
+   * For example if you’re transferring USDT this would be the USDT address
+   * @param recipient The recipient account address
+   * @param amount Number of assets to transfer
+   *
+   * @returns A SingleSignerTransaction that can be simulated or submitted to chain.
+   */
+  async transferFungibleAsset(args: {
+    sender: Account;
+    fungibleAssetMetadataAddress: AccountAddress;
+    recipient: AccountAddress;
+    amount: AnyNumber;
+    options?: InputGenerateTransactionOptions;
+  }): Promise<SingleSignerTransaction> {
+    return transferFungibleAsset({ aptosConfig: this.config, ...args });
+  }
 }

package/src/api/general.ts

@@ -8,6 +8,7 @@ import {
   getChainTopUserTransactions,
   getIndexerLastSuccessVersion,
   getLedgerInfo,
+  getProcessorStatus,
   getTableItem,
   queryIndexer,
   view,
@@ -16,13 +17,15 @@ import {
   AnyNumber,
   Block,
   GetChainTopUserTransactionsResponse,
+  GetProcessorStatusResponse,
   GraphqlQuery,
   LedgerInfo,
-  LedgerVersion,
+  LedgerVersionArg,
   MoveValue,
   TableItemRequest,
   InputViewRequestData,
 } from "../types";
+import { ProcessorType } from "../utils/const";
 
 /**
  * A class to query all `General` Aptos related queries
@@ -114,7 +117,7 @@ export class General {
    *
    * @returns Table item value rendered in JSON
    */
-  async getTableItem<T>(args: { handle: string; data: TableItemRequest; options?: LedgerVersion }): Promise<T> {
+  async getTableItem<T>(args: { handle: string; data: TableItemRequest; options?: LedgerVersionArg }): Promise<T> {
     return getTableItem<T>({ aptosConfig: this.config, ...args });
   }
 
@@ -133,7 +136,10 @@ export class General {
    *
    * @returns an array of Move values
    */
-  async view<T extends Array<MoveValue>>(args: { payload: InputViewRequestData; options?: LedgerVersion }): Promise<T> {
+  async view<T extends Array<MoveValue>>(args: {
+    payload: InputViewRequestData;
+    options?: LedgerVersionArg;
+  }): Promise<T> {
     return view<T>({ aptosConfig: this.config, ...args });
   }
 
@@ -185,4 +191,14 @@ export class General {
   async getIndexerLastSuccessVersion(): Promise<number> {
     return getIndexerLastSuccessVersion({ aptosConfig: this.config });
   }
+
+  /**
+   * Query the processor status for a specific processor type.
+   *
+   * @param processorType The processor type to query
+   * @returns
+   */
+  async getProcessorStatus(processorType: ProcessorType): Promise<GetProcessorStatusResponse[0]> {
+    return getProcessorStatus({ aptosConfig: this.config, processorType });
+  }
 }