@aptos-labs/ts-sdk 6.3.1 → 7.0.1

package/dist/api/transactionSubmission/simulate.js

@@ -0,0 +1,183 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { simulateTransaction } from "../../internal/transactionSubmission.js";
+import { ValidateFeePayerDataOnSimulation } from "./helpers.js";
+/**
+ * A class to handle all `Simulate` transaction operations.
+ * @group Implementation
+ */
+export class Simulate {
+    config;
+    /**
+     * Initializes a new instance of the Aptos client with the specified configuration.
+     * This allows you to interact with the Aptos blockchain using the provided settings.
+     *
+     * @param config - The configuration settings for the Aptos client.
+     * @param config.network - The network to connect to (e.g., TESTNET, MAINNET).
+     * @param config.nodeUrl - The URL of the Aptos node to connect to.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * async function runExample() {
+     *     // Create a configuration for the Aptos client
+     *     const config = new AptosConfig({ network: Network.TESTNET }); // Specify your desired network
+     *
+     *     // Initialize the Aptos client with the configuration
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client initialized:", aptos);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Simulates a transaction based on the provided parameters and returns the result.
+     * This function helps you understand the outcome of a transaction before executing it on the blockchain.
+     *
+     * @param args - The parameters for simulating the transaction.
+     * @param args.signerPublicKey - The public key of the signer for the transaction (optional).
+     * @param args.transaction - The raw transaction data to simulate.
+     * @param args.feePayerPublicKey - The public key of the fee payer (optional).
+     * @param args.options - Additional options for simulating the transaction (optional).
+     *
+     * @example
+     * ```typescript
+     * import {
+     *     Account,
+     *     Aptos,
+     *     AptosConfig,
+     *     Network,
+     * } from "@aptos-labs/ts-sdk";
+     *
+     * async function example() {
+     *     let sender = Account.generate();
+     *     let receiver = Account.generate();
+     *
+     *     // 0. Set up the client and test accounts
+     *     const config = new AptosConfig({ network: Network.DEVNET });
+     *     const aptos = new Aptos(config);
+     *
+     *     await aptos.fundAccount({
+     *         accountAddress: sender.accountAddress,
+     *         amount: 100_000_000,
+     *     });
+     *
+     *     // 1. Build the transaction to preview the impact of it
+     *     const transaction = await aptos.transaction.build.simple({
+     *         sender: sender.accountAddress,
+     *         data: {
+     *             // All transactions on Aptos are implemented via smart contracts.
+     *             function: "0x1::aptos_account::transfer",
+     *             functionArguments: [receiver.accountAddress, 100],
+     *         },
+     *     });
+     *
+     *     // 2. Simulate to see what would happen if we execute this transaction
+     *     const [userTransactionResponse] = await aptos.transaction.simulate.simple({
+     *         signerPublicKey: sender.publicKey,
+     *         transaction,
+     *     });
+     *     console.log(userTransactionResponse);
+     *
+     *     // If the fee looks ok, continue to signing!
+     *     // ...
+     * }
+     *
+     * example();
+     * ```
+     * @group Implementation
+     */
+    async simple(args) {
+        return simulateTransaction({ aptosConfig: this.config, ...args });
+    }
+    /**
+     * Simulates a multi-agent transaction by generating a signed transaction and posting it to the Aptos full node.
+     * This function helps in understanding the outcome of a transaction involving multiple signers before it is executed.
+     *
+     * @param args - The parameters for simulating the transaction.
+     * @param args.signerPublicKey - The public key of the primary signer (optional).
+     * @param args.transaction - The raw transaction to be simulated.
+     * @param args.secondarySignersPublicKeys - An array of public keys for secondary signers (optional).
+     *        Each element of the array can be optional, allowing the corresponding key check to be skipped.
+     * @param args.feePayerPublicKey - The public key of the fee payer (optional).
+     * @param args.options - Options for simulating the transaction (optional).
+     *
+     * @example
+     * ```typescript
+     * import {
+     *     Account,
+     *     Aptos,
+     *     AptosConfig,
+     *     Network,
+     * } from "@aptos-labs/ts-sdk";
+     *
+     * async function example() {
+     *     let sender1 = Account.generate();
+     *     let sender2 = Account.generate();
+     *     let receiver = Account.generate();
+     *
+     *     // 0. Set up the client and test accounts
+     *     const config = new AptosConfig({ network: Network.DEVNET });
+     *     const aptos = new Aptos(config);
+     *
+     *     await aptos.fundAccount({
+     *         accountAddress: sender.accountAddress,
+     *         amount: 100_000_000,
+     *     });
+     *
+     *     // 1. Build
+     *     console.log("\n=== 1. Building the transaction ===\n");
+     *     const transaction = await aptos.transaction.build.multiAgent({
+     *     sender: sender1.accountAddress,
+     *     secondarySignerAddresses: [sender2.accountAddress],
+     *     data: {
+     *        // REPLACE WITH YOUR MULTI-AGENT FUNCTION HERE
+     *        function:
+     *          "<REPLACE WITH YOUR MULTI AGENT MOVE ENTRY FUNCTION> (Syntax {address}::{module}::{function})",
+     *          functionArguments: [],
+     *        },
+     *      });
+     *      console.log("Transaction:", transaction);
+     *
+     *      // 2. Simulate (Optional)
+     *      console.log("\n === 2. Simulating Response (Optional) === \n");
+     *      const [userTransactionResponse] = await aptos.transaction.simulate.multiAgent(
+     *        {
+     *          signerPublicKey: sender1.publicKey,
+     *          secondarySignersPublicKeys: [sender2.publicKey],
+     *          transaction,
+     *        },
+     *      );
+     *      console.log(userTransactionResponse);
+     *
+     *      // If the fee looks ok, continue to signing!
+     *      // ...
+     * }
+     *
+     * example();
+     * ```
+     * @group Implementation
+     */
+    async multiAgent(args) {
+        return simulateTransaction({ aptosConfig: this.config, ...args });
+    }
+}
+__decorate([
+    ValidateFeePayerDataOnSimulation
+], Simulate.prototype, "simple", null);
+__decorate([
+    ValidateFeePayerDataOnSimulation
+], Simulate.prototype, "multiAgent", null);
+//# sourceMappingURL=simulate.js.map

package/dist/api/transactionSubmission/simulate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate.js","sourceRoot":"","sources":["../../../src/api/transactionSubmission/simulate.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,sCAAsC;;;;;;;AAGtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAI9E,OAAO,EAAE,gCAAgC,EAAE,MAAM,cAAc,CAAC;AAEhE;;;GAGG;AACH,MAAM,OAAO,QAAQ;IACV,MAAM,CAAc;IAE7B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,YAAY,MAAmB;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDG;IAEG,AAAN,KAAK,CAAC,MAAM,CAAC,IAKZ;QACC,OAAO,mBAAmB,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmEG;IAEG,AAAN,KAAK,CAAC,UAAU,CAAC,IAMhB;QACC,OAAO,mBAAmB,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;IACpE,CAAC;CACF;AAvFO;IADL,gCAAgC;sCAQhC;AAuEK;IADL,gCAAgC;0CAShC"}

package/dist/api/transactionSubmission/submit.d.ts

@@ -0,0 +1,136 @@
+import { AccountAuthenticator, AnyRawTransaction, InputTransactionPluginData } from "../../transactions/index.js";
+import { PendingTransactionResponse } from "../../types/index.js";
+import { AptosConfig } from "../aptosConfig.js";
+/**
+ * A class to handle all `Submit` transaction operations.
+ * @group Implementation
+ */
+export declare class Submit {
+    readonly config: AptosConfig;
+    /**
+     * Initializes a new instance of the Aptos client with the specified configuration.
+     * This allows you to interact with the Aptos blockchain using the provided settings.
+     *
+     * @param config - The configuration settings for the Aptos client.
+     * @param config.network - The network to connect to (e.g., TESTNET, MAINNET).
+     * @param config.nodeUrl - The URL of the Aptos node to connect to.
+     * @param config.faucetUrl - The URL of the faucet for obtaining test tokens.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * async function runExample() {
+     *     // Create a configuration for the Aptos client
+     *     const config = new AptosConfig({
+     *         network: Network.TESTNET, // Use the TESTNET for testing
+     *         nodeUrl: "https://testnet.aptos.dev", // Specify the node URL
+     *         faucetUrl: "https://faucet.testnet.aptos.dev" // Specify the faucet URL
+     *     });
+     *
+     *     // Initialize the Aptos client with the configuration
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client initialized:", aptos);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    constructor(config: AptosConfig);
+    /**
+     * Submits a transaction to the Aptos blockchain using the provided transaction details and authenticators.
+     * This function allows you to execute transactions securely by specifying the sender and optional fee payer authenticators.
+     *
+     * @param args - The arguments for submitting the transaction.
+     * @param args.transaction - The raw transaction data to be submitted.
+     * @param args.senderAuthenticator - The authenticator for the sender's account.
+     * @param [args.feePayerAuthenticator] - The optional authenticator for the fee payer's account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   const sender = Account.generate(); // Generate a new sender account
+     *   const transaction = await aptos.transaction.build.simple({
+     *     sender: sender.accountAddress,
+     *     data: {
+     *       function: "0x1::aptos_account::transfer",
+     *       functionArguments: [Account.generate().accountAddress, 100], // Replace with a real destination account
+     *     },
+     *   });
+     *
+     *   // Submit the transaction
+     *   const response = await aptos.simple({
+     *     transaction,
+     *     senderAuthenticator: sender.getAuthenticator(), // Use the sender's authenticator
+     *   });
+     *
+     *   console.log("Transaction submitted:", response);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    simple(args: {
+        transaction: AnyRawTransaction;
+        senderAuthenticator: AccountAuthenticator;
+        feePayerAuthenticator?: AccountAuthenticator;
+    } & InputTransactionPluginData): Promise<PendingTransactionResponse>;
+    /**
+     * Submits a multi-agent transaction to the Aptos network, allowing multiple signers to authorize the transaction.
+     * This function is useful for scenarios where a transaction requires approval from multiple accounts.
+     *
+     * @param args - The parameters for the multi-agent transaction.
+     * @param args.transaction - The raw transaction to be submitted.
+     * @param args.senderAuthenticator - The authenticator for the sender account.
+     * @param args.additionalSignersAuthenticators - An array of authenticators for additional signers.
+     * @param [args.feePayerAuthenticator] - An optional authenticator for the fee payer account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   const sender = Account.generate(); // Generate a new sender account
+     *   const additionalSigner1 = Account.generate(); // Generate an additional signer account
+     *   const additionalSigner2 = Account.generate(); // Generate another additional signer account
+     *
+     *   const transaction = await aptos.transaction.build.simple({
+     *     sender: sender.accountAddress,
+     *     data: {
+     *       function: "0x1::aptos_account::transfer",
+     *       functionArguments: [additionalSigner1.accountAddress, 100],
+     *     },
+     *   });
+     *
+     *   const response = await aptos.multiAgent({
+     *     transaction,
+     *     senderAuthenticator: sender.getAuthenticator(), // Use the sender's authenticator
+     *     additionalSignersAuthenticators: [
+     *       additionalSigner1.getAuthenticator(), // Use the first additional signer's authenticator
+     *       additionalSigner2.getAuthenticator(), // Use the second additional signer's authenticator
+     *     ],
+     *   });
+     *
+     *   console.log(response); // Log the response from the transaction submission
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    multiAgent(args: {
+        transaction: AnyRawTransaction;
+        senderAuthenticator: AccountAuthenticator;
+        additionalSignersAuthenticators: Array<AccountAuthenticator>;
+        feePayerAuthenticator?: AccountAuthenticator;
+    } & InputTransactionPluginData): Promise<PendingTransactionResponse>;
+}
+//# sourceMappingURL=submit.d.ts.map

package/dist/api/transactionSubmission/submit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit.d.ts","sourceRoot":"","sources":["../../../src/api/transactionSubmission/submit.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAClH,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD;;;GAGG;AACH,qBAAa,MAAM;IACjB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;gBACS,MAAM,EAAE,WAAW;IAI/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACG,MAAM,CACV,IAAI,EAAE;QACJ,WAAW,EAAE,iBAAiB,CAAC;QAC/B,mBAAmB,EAAE,oBAAoB,CAAC;QAC1C,qBAAqB,CAAC,EAAE,oBAAoB,CAAC;KAC9C,GAAG,0BAA0B,GAC7B,OAAO,CAAC,0BAA0B,CAAC;IAKtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACG,UAAU,CACd,IAAI,EAAE;QACJ,WAAW,EAAE,iBAAiB,CAAC;QAC/B,mBAAmB,EAAE,oBAAoB,CAAC;QAC1C,+BAA+B,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC;QAC7D,qBAAqB,CAAC,EAAE,oBAAoB,CAAC;KAC9C,GAAG,0BAA0B,GAC7B,OAAO,CAAC,0BAA0B,CAAC;CAIvC"}

package/dist/api/transactionSubmission/submit.js

@@ -0,0 +1,136 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+import { submitTransaction } from "../../internal/transactionSubmission.js";
+import { validateFeePayerDataOnSubmission } from "./helpers.js";
+/**
+ * A class to handle all `Submit` transaction operations.
+ * @group Implementation
+ */
+export class Submit {
+    config;
+    /**
+     * Initializes a new instance of the Aptos client with the specified configuration.
+     * This allows you to interact with the Aptos blockchain using the provided settings.
+     *
+     * @param config - The configuration settings for the Aptos client.
+     * @param config.network - The network to connect to (e.g., TESTNET, MAINNET).
+     * @param config.nodeUrl - The URL of the Aptos node to connect to.
+     * @param config.faucetUrl - The URL of the faucet for obtaining test tokens.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * async function runExample() {
+     *     // Create a configuration for the Aptos client
+     *     const config = new AptosConfig({
+     *         network: Network.TESTNET, // Use the TESTNET for testing
+     *         nodeUrl: "https://testnet.aptos.dev", // Specify the node URL
+     *         faucetUrl: "https://faucet.testnet.aptos.dev" // Specify the faucet URL
+     *     });
+     *
+     *     // Initialize the Aptos client with the configuration
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client initialized:", aptos);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Submits a transaction to the Aptos blockchain using the provided transaction details and authenticators.
+     * This function allows you to execute transactions securely by specifying the sender and optional fee payer authenticators.
+     *
+     * @param args - The arguments for submitting the transaction.
+     * @param args.transaction - The raw transaction data to be submitted.
+     * @param args.senderAuthenticator - The authenticator for the sender's account.
+     * @param [args.feePayerAuthenticator] - The optional authenticator for the fee payer's account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   const sender = Account.generate(); // Generate a new sender account
+     *   const transaction = await aptos.transaction.build.simple({
+     *     sender: sender.accountAddress,
+     *     data: {
+     *       function: "0x1::aptos_account::transfer",
+     *       functionArguments: [Account.generate().accountAddress, 100], // Replace with a real destination account
+     *     },
+     *   });
+     *
+     *   // Submit the transaction
+     *   const response = await aptos.simple({
+     *     transaction,
+     *     senderAuthenticator: sender.getAuthenticator(), // Use the sender's authenticator
+     *   });
+     *
+     *   console.log("Transaction submitted:", response);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    async simple(args) {
+        validateFeePayerDataOnSubmission(this.config, args);
+        return submitTransaction({ aptosConfig: this.config, ...args });
+    }
+    /**
+     * Submits a multi-agent transaction to the Aptos network, allowing multiple signers to authorize the transaction.
+     * This function is useful for scenarios where a transaction requires approval from multiple accounts.
+     *
+     * @param args - The parameters for the multi-agent transaction.
+     * @param args.transaction - The raw transaction to be submitted.
+     * @param args.senderAuthenticator - The authenticator for the sender account.
+     * @param args.additionalSignersAuthenticators - An array of authenticators for additional signers.
+     * @param [args.feePayerAuthenticator] - An optional authenticator for the fee payer account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   const sender = Account.generate(); // Generate a new sender account
+     *   const additionalSigner1 = Account.generate(); // Generate an additional signer account
+     *   const additionalSigner2 = Account.generate(); // Generate another additional signer account
+     *
+     *   const transaction = await aptos.transaction.build.simple({
+     *     sender: sender.accountAddress,
+     *     data: {
+     *       function: "0x1::aptos_account::transfer",
+     *       functionArguments: [additionalSigner1.accountAddress, 100],
+     *     },
+     *   });
+     *
+     *   const response = await aptos.multiAgent({
+     *     transaction,
+     *     senderAuthenticator: sender.getAuthenticator(), // Use the sender's authenticator
+     *     additionalSignersAuthenticators: [
+     *       additionalSigner1.getAuthenticator(), // Use the first additional signer's authenticator
+     *       additionalSigner2.getAuthenticator(), // Use the second additional signer's authenticator
+     *     ],
+     *   });
+     *
+     *   console.log(response); // Log the response from the transaction submission
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    async multiAgent(args) {
+        validateFeePayerDataOnSubmission(this.config, args);
+        return submitTransaction({ aptosConfig: this.config, ...args });
+    }
+}
+//# sourceMappingURL=submit.js.map

package/dist/api/transactionSubmission/submit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit.js","sourceRoot":"","sources":["../../../src/api/transactionSubmission/submit.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,sCAAsC;AAEtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAI5E,OAAO,EAAE,gCAAgC,EAAE,MAAM,cAAc,CAAC;AAEhE;;;GAGG;AACH,MAAM,OAAO,MAAM;IACR,MAAM,CAAc;IAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,YAAY,MAAmB;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,KAAK,CAAC,MAAM,CACV,IAI8B;QAE9B,gCAAgC,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACpD,OAAO,iBAAiB,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,KAAK,CAAC,UAAU,CACd,IAK8B;QAE9B,gCAAgC,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACpD,OAAO,iBAAiB,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;IAClE,CAAC;CACF"}

package/dist/api/utils.d.ts

@@ -0,0 +1,39 @@
+import { ProcessorType } from "../utils/index.js";
+import { AptosConfig } from "./aptosConfig.js";
+import { AnyNumber } from "../types/index.js";
+/**
+ * Waits for the indexer to reach a specified ledger version, allowing for synchronization with the blockchain.
+ * This function is useful for ensuring that your application is working with the most up-to-date data before proceeding.
+ *
+ * @param args - The parameters for waiting on the indexer.
+ * @param args.config - The configuration object for Aptos.
+ * @param [args.minimumLedgerVersion] - The minimum ledger version to wait for. If not specified, the function will not wait.
+ * @param args.processorType - The type of processor to wait for.
+ *
+ * @example
+ * ```typescript
+ * import { Aptos, AptosConfig, Network, ProcessorType } from "@aptos-labs/ts-sdk";
+ *
+ * const config = new AptosConfig({ network: Network.TESTNET });
+ * const aptos = new Aptos(config);
+ *
+ * async function runExample() {
+ *   // Wait for the indexer to reach a specific ledger version
+ *   await aptos.waitForIndexerOnVersion({
+ *     config: config,
+ *     minimumLedgerVersion: 1000n, // replace with a real ledger version
+ *     processorType: ProcessorType.DEFAULT,
+ *   });
+ *
+ *   console.log("Indexer is synced to the specified ledger version.");
+ * }
+ * runExample().catch(console.error);
+ * ```
+ * @group Implementation
+ */
+export declare function waitForIndexerOnVersion(args: {
+    config: AptosConfig;
+    minimumLedgerVersion?: AnyNumber;
+    processorType: ProcessorType;
+}): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/api/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/api/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAClD,MAAM,EAAE,WAAW,CAAC;IACpB,oBAAoB,CAAC,EAAE,SAAS,CAAC;IACjC,aAAa,EAAE,aAAa,CAAC;CAC9B,iBAQA"}

package/dist/api/utils.js

@@ -0,0 +1,41 @@
+import { waitForIndexer } from "../internal/transaction.js";
+/**
+ * Waits for the indexer to reach a specified ledger version, allowing for synchronization with the blockchain.
+ * This function is useful for ensuring that your application is working with the most up-to-date data before proceeding.
+ *
+ * @param args - The parameters for waiting on the indexer.
+ * @param args.config - The configuration object for Aptos.
+ * @param [args.minimumLedgerVersion] - The minimum ledger version to wait for. If not specified, the function will not wait.
+ * @param args.processorType - The type of processor to wait for.
+ *
+ * @example
+ * ```typescript
+ * import { Aptos, AptosConfig, Network, ProcessorType } from "@aptos-labs/ts-sdk";
+ *
+ * const config = new AptosConfig({ network: Network.TESTNET });
+ * const aptos = new Aptos(config);
+ *
+ * async function runExample() {
+ *   // Wait for the indexer to reach a specific ledger version
+ *   await aptos.waitForIndexerOnVersion({
+ *     config: config,
+ *     minimumLedgerVersion: 1000n, // replace with a real ledger version
+ *     processorType: ProcessorType.DEFAULT,
+ *   });
+ *
+ *   console.log("Indexer is synced to the specified ledger version.");
+ * }
+ * runExample().catch(console.error);
+ * ```
+ * @group Implementation
+ */
+export async function waitForIndexerOnVersion(args) {
+    if (args.minimumLedgerVersion !== undefined) {
+        await waitForIndexer({
+            aptosConfig: args.config,
+            minimumLedgerVersion: args.minimumLedgerVersion,
+            processorType: args.processorType,
+        });
+    }
+}
+//# sourceMappingURL=utils.js.map

package/dist/api/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/api/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAK5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAC,IAI7C;IACC,IAAI,IAAI,CAAC,oBAAoB,KAAK,SAAS,EAAE,CAAC;QAC5C,MAAM,cAAc,CAAC;YACnB,WAAW,EAAE,IAAI,CAAC,MAAM;YACxB,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,aAAa,EAAE,IAAI,CAAC,aAAa;SAClC,CAAC,CAAC;IACL,CAAC;AACH,CAAC"}

package/dist/bcs/consts.d.ts

@@ -0,0 +1,20 @@
+import { Uint8, Uint16, Uint32, Uint64, Uint128, Uint256, Int8, Int16, Int32, Int64, Int128, Int256 } from "../types/index.js";
+export declare const MAX_U8_NUMBER: Uint8;
+export declare const MAX_U16_NUMBER: Uint16;
+export declare const MAX_U32_NUMBER: Uint32;
+export declare const MAX_U64_BIG_INT: Uint64;
+export declare const MAX_U128_BIG_INT: Uint128;
+export declare const MAX_U256_BIG_INT: Uint256;
+export declare const MIN_I8_NUMBER: Int8;
+export declare const MAX_I8_NUMBER: Int8;
+export declare const MIN_I16_NUMBER: Int16;
+export declare const MAX_I16_NUMBER: Int16;
+export declare const MIN_I32_NUMBER: Int32;
+export declare const MAX_I32_NUMBER: Int32;
+export declare const MIN_I64_BIG_INT: Int64;
+export declare const MAX_I64_BIG_INT: Int64;
+export declare const MIN_I128_BIG_INT: Int128;
+export declare const MAX_I128_BIG_INT: Int128;
+export declare const MIN_I256_BIG_INT: Int256;
+export declare const MAX_I256_BIG_INT: Int256;
+//# sourceMappingURL=consts.d.ts.map

package/dist/bcs/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../../src/bcs/consts.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,EACL,MAAM,EACN,MAAM,EACN,MAAM,EACN,OAAO,EACP,OAAO,EACP,IAAI,EACJ,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,MAAM,EACP,MAAM,mBAAmB,CAAC;AAI3B,eAAO,MAAM,aAAa,EAAE,KAAW,CAAC;AACxC,eAAO,MAAM,cAAc,EAAE,MAAc,CAAC;AAC5C,eAAO,MAAM,cAAc,EAAE,MAAmB,CAAC;AACjD,eAAO,MAAM,eAAe,EAAE,MAA8B,CAAC;AAC7D,eAAO,MAAM,gBAAgB,EAAE,OAAkD,CAAC;AAClF,eAAO,MAAM,gBAAgB,EAAE,OACkD,CAAC;AAGlF,eAAO,MAAM,aAAa,EAAE,IAAW,CAAC;AACxC,eAAO,MAAM,aAAa,EAAE,IAAU,CAAC;AACvC,eAAO,MAAM,cAAc,EAAE,KAAc,CAAC;AAC5C,eAAO,MAAM,cAAc,EAAE,KAAa,CAAC;AAC3C,eAAO,MAAM,cAAc,EAAE,KAAmB,CAAC;AACjD,eAAO,MAAM,cAAc,EAAE,KAAkB,CAAC;AAChD,eAAO,MAAM,eAAe,EAAE,KAA6B,CAAC;AAC5D,eAAO,MAAM,eAAe,EAAE,KAA4B,CAAC;AAC3D,eAAO,MAAM,gBAAgB,EAAE,MAAkD,CAAC;AAClF,eAAO,MAAM,gBAAgB,EAAE,MAAiD,CAAC;AACjF,eAAO,MAAM,gBAAgB,EAAE,MAAwF,CAAC;AACxH,eAAO,MAAM,gBAAgB,EAAE,MAAuF,CAAC"}

package/dist/bcs/consts.js

@@ -0,0 +1,24 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Upper bound values for uint8, uint16, uint64 etc.  These are all derived as
+// 2^N - 1, where N is the number of bits in the type.
+export const MAX_U8_NUMBER = 255;
+export const MAX_U16_NUMBER = 65535;
+export const MAX_U32_NUMBER = 4294967295;
+export const MAX_U64_BIG_INT = 18446744073709551615n;
+export const MAX_U128_BIG_INT = 340282366920938463463374607431768211455n;
+export const MAX_U256_BIG_INT = 115792089237316195423570985008687907853269984665640564039457584007913129639935n;
+// Signed integer bounds
+export const MIN_I8_NUMBER = -128;
+export const MAX_I8_NUMBER = 127;
+export const MIN_I16_NUMBER = -32768;
+export const MAX_I16_NUMBER = 32767;
+export const MIN_I32_NUMBER = -2147483648;
+export const MAX_I32_NUMBER = 2147483647;
+export const MIN_I64_BIG_INT = -9223372036854775808n;
+export const MAX_I64_BIG_INT = 9223372036854775807n;
+export const MIN_I128_BIG_INT = -170141183460469231731687303715884105728n;
+export const MAX_I128_BIG_INT = 170141183460469231731687303715884105727n;
+export const MIN_I256_BIG_INT = -57896044618658097711785492504343953926634992332820282019728792003956564819968n;
+export const MAX_I256_BIG_INT = 57896044618658097711785492504343953926634992332820282019728792003956564819967n;
+//# sourceMappingURL=consts.js.map

package/dist/bcs/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../../src/bcs/consts.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,sCAAsC;AAiBtC,8EAA8E;AAC9E,sDAAsD;AACtD,MAAM,CAAC,MAAM,aAAa,GAAU,GAAG,CAAC;AACxC,MAAM,CAAC,MAAM,cAAc,GAAW,KAAK,CAAC;AAC5C,MAAM,CAAC,MAAM,cAAc,GAAW,UAAU,CAAC;AACjD,MAAM,CAAC,MAAM,eAAe,GAAW,qBAAqB,CAAC;AAC7D,MAAM,CAAC,MAAM,gBAAgB,GAAY,wCAAwC,CAAC;AAClF,MAAM,CAAC,MAAM,gBAAgB,GAC3B,+EAA+E,CAAC;AAElF,wBAAwB;AACxB,MAAM,CAAC,MAAM,aAAa,GAAS,CAAC,GAAG,CAAC;AACxC,MAAM,CAAC,MAAM,aAAa,GAAS,GAAG,CAAC;AACvC,MAAM,CAAC,MAAM,cAAc,GAAU,CAAC,KAAK,CAAC;AAC5C,MAAM,CAAC,MAAM,cAAc,GAAU,KAAK,CAAC;AAC3C,MAAM,CAAC,MAAM,cAAc,GAAU,CAAC,UAAU,CAAC;AACjD,MAAM,CAAC,MAAM,cAAc,GAAU,UAAU,CAAC;AAChD,MAAM,CAAC,MAAM,eAAe,GAAU,CAAC,oBAAoB,CAAC;AAC5D,MAAM,CAAC,MAAM,eAAe,GAAU,oBAAoB,CAAC;AAC3D,MAAM,CAAC,MAAM,gBAAgB,GAAW,CAAC,wCAAwC,CAAC;AAClF,MAAM,CAAC,MAAM,gBAAgB,GAAW,wCAAwC,CAAC;AACjF,MAAM,CAAC,MAAM,gBAAgB,GAAW,CAAC,8EAA8E,CAAC;AACxH,MAAM,CAAC,MAAM,gBAAgB,GAAW,8EAA8E,CAAC"}