@aptos-labs/ts-sdk 0.0.6 → 0.0.8

package/src/api/aptos.ts

@@ -13,6 +13,10 @@ import { ANS } from "./ans";
 import { Staking } from "./staking";
 import { Transaction } from "./transaction";
 import { TransactionSubmission } from "./transactionSubmission";
+import { Build } from "./transactionSubmission/build";
+import { Sign } from "./transactionSubmission/sign";
+import { Simulate } from "./transactionSubmission/simulate";
+import { Submit } from "./transactionSubmission/submit";
 
 /**
  * This class is the main entry point into Aptos's
@@ -46,6 +50,14 @@ export class Aptos {
 
   readonly transactionSubmission: TransactionSubmission;
 
+  readonly build: Build;
+
+  readonly sign: Sign;
+
+  readonly simulate: Simulate;
+
+  readonly submit: Submit;
+
   constructor(settings?: AptosConfig) {
     this.config = new AptosConfig(settings);
     this.account = new Account(this.config);
@@ -59,6 +71,10 @@ export class Aptos {
     this.staking = new Staking(this.config);
     this.transaction = new Transaction(this.config);
     this.transactionSubmission = new TransactionSubmission(this.config);
+    this.build = new Build(this.config);
+    this.sign = new Sign(this.config);
+    this.simulate = new Simulate(this.config);
+    this.submit = new Submit(this.config);
   }
 }
 
@@ -107,3 +123,7 @@ applyMixin(Aptos, General, "general");
 applyMixin(Aptos, Staking, "staking");
 applyMixin(Aptos, Transaction, "transaction");
 applyMixin(Aptos, TransactionSubmission, "transactionSubmission");
+applyMixin(Aptos, Build, "build");
+applyMixin(Aptos, Sign, "sign");
+applyMixin(Aptos, Simulate, "simulate");
+applyMixin(Aptos, Submit, "submit");

package/src/api/aptosConfig.ts

@@ -10,11 +10,11 @@ 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. */
+  /** The Network that this SDK is associated with. Defaults to DEVNET */
   readonly network: Network;
 
   /**
-   * The client instance the SDK uses
+   * The client instance the SDK uses. Defaults to `@aptos-labs/aptos-client
    */
   readonly client: Client;
 

package/src/api/coin.ts

@@ -1,21 +1,17 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AptosConfig } from "./aptosConfig";
 import { Account, AccountAddressInput } from "../core";
 import { transferCoinTransaction } from "../internal/coin";
-import { InputSingleSignerTransaction, InputGenerateTransactionOptions } from "../transactions/types";
+import { SingleSignerTransaction, InputGenerateTransactionOptions } from "../transactions/types";
 import { AnyNumber, MoveStructId } from "../types";
+import { AptosConfig } from "./aptosConfig";
 
 /**
  * A class to handle all `Coin` operations
  */
 export class Coin {
-  readonly config: AptosConfig;
-
-  constructor(config: AptosConfig) {
-    this.config = config;
-  }
+  constructor(readonly config: AptosConfig) {}
 
   /**
    * Generate a transfer coin transaction that can be simulated and/or signed and submitted
@@ -33,7 +29,7 @@ export class Coin {
     amount: AnyNumber;
     coinType?: MoveStructId;
     options?: InputGenerateTransactionOptions;
-  }): Promise<InputSingleSignerTransaction> {
+  }): Promise<SingleSignerTransaction> {
     return transferCoinTransaction({ aptosConfig: this.config, ...args });
   }
 }

package/src/api/digitalAsset.ts

@@ -2,18 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {
+  AnyNumber,
   GetCollectionDataResponse,
   GetCurrentTokenOwnershipResponse,
   GetOwnedTokensResponse,
   GetTokenActivityResponse,
   GetTokenDataResponse,
-  OrderBy,
+  OrderByArg,
   PaginationArgs,
   TokenStandard,
+  TokenStandardArg,
 } from "../types";
-import { AptosConfig } from "./aptosConfig";
 import { Account, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
+import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
 import {
   CreateCollectionOptions,
   createCollectionTransaction,
@@ -25,16 +26,15 @@ import {
   getTokenData,
   mintTokenTransaction,
 } 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
@@ -69,7 +69,7 @@ export class DigitalAsset {
       uri: string;
       options?: InputGenerateTransactionOptions;
     } & CreateCollectionOptions,
-  ): Promise<InputSingleSignerTransaction> {
+  ): Promise<SingleSignerTransaction> {
     return createCollectionTransaction({ aptosConfig: this.config, ...args });
   }
 
@@ -81,16 +81,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 +107,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 });
   }
 
@@ -133,7 +143,7 @@ export class DigitalAsset {
     name: string;
     uri: string;
     options?: InputGenerateTransactionOptions;
-  }): Promise<InputSingleSignerTransaction> {
+  }): Promise<SingleSignerTransaction> {
     return mintTokenTransaction({ aptosConfig: this.config, ...args });
   }
 
@@ -141,9 +151,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 +171,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 +191,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 +212,32 @@ 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 });
   }
 }
+
+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 });
+  }
 }