@aptos-labs/ts-sdk 6.3.1 → 7.0.1

package/dist/api/transactionSubmission/management.js

@@ -0,0 +1,192 @@
+import { EventEmitter } from "eventemitter3";
+import { TransactionWorker, TransactionWorkerEventsEnum, } from "../../transactions/management/index.js";
+export class TransactionManagement extends EventEmitter {
+    account;
+    transactionWorker;
+    config;
+    /**
+     * Initializes a new instance of the Aptos client with the provided configuration settings.
+     * This allows you to interact with the Aptos blockchain using the specified network and options.
+     *
+     * @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.account - Optional account settings for authentication.
+     *
+     * @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 the network to use
+     *         nodeUrl: "https://testnet.aptos.dev" // replace with your node URL
+     *     });
+     *
+     *     // Initialize the Aptos client with the configuration
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client initialized successfully.");
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    /**
+     * Initializes the transaction worker using the provided sender account and begins listening for events.
+     * This function is essential for setting up the transaction processing environment.
+     *
+     * @param args - The arguments for starting the transaction worker.
+     * @param args.sender - The sender account to sign and submit the transaction.
+     *
+     * @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 account for sending transactions
+     *
+     *     // Start the transaction worker with the sender account
+     *     aptos.start({ sender });
+     *
+     *     console.log("Transaction worker started with sender:", sender.accountAddress);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    start(args) {
+        const { sender } = args;
+        this.account = sender;
+        this.transactionWorker = new TransactionWorker(this.config, sender);
+        this.transactionWorker.start();
+        this.registerToEvents();
+    }
+    /**
+     * Pushes transaction data to the transaction worker for processing.
+     *
+     * @param args.data An array of transaction payloads to be processed.
+     * @param args.options Optional. Transaction generation configurations (excluding accountSequenceNumber).
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Prepare transaction payloads
+     *   const payloads = [
+     *      {}, // Build your first transaction payload
+     *      {}, // Build your second transaction payload
+     *   ];
+     *
+     *   // Push transaction data to the worker
+     *   aptos.push({
+     *     data: payloads,
+     *     {}, // Specify options as needed
+     *   });
+     *
+     *   console.log("Transaction data pushed successfully.");
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    push(args) {
+        const { data, options } = args;
+        for (const d of data) {
+            this.transactionWorker.push(d, options);
+        }
+    }
+    /**
+     * Starts listening to transaction worker events, allowing the application to respond to transaction status changes.
+     * This function enables the application to handle events such as transaction sent, execution success, or failure.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Register to listen for transaction events
+     *   aptos.registerToEvents();
+     *
+     *   // You can send a transaction here to see the events in action
+     *   const sender = Account.generate(); // replace with a real account
+     *   const destination = Account.generate(); // replace with a real account
+     *
+     *   const transaction = await aptos.transaction.build.simple({
+     *     sender: sender.accountAddress,
+     *     data: {
+     *       function: "0x1::aptos_account::transfer",
+     *       functionArguments: [destination.accountAddress, 100],
+     *     },
+     *   });
+     *
+     *   await aptos.transaction.send(transaction);
+     *
+     *   console.log("Transaction sent and events registered.");
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    registerToEvents() {
+        // TODO - Should we ask events to listen to this as an input?
+        this.transactionWorker.on(TransactionWorkerEventsEnum.TransactionSent, async (data) => {
+            this.emit(TransactionWorkerEventsEnum.TransactionSent, data);
+        });
+        this.transactionWorker.on(TransactionWorkerEventsEnum.TransactionSendFailed, async (data) => {
+            this.emit(TransactionWorkerEventsEnum.TransactionSendFailed, data);
+        });
+        this.transactionWorker.on(TransactionWorkerEventsEnum.TransactionExecuted, async (data) => {
+            this.emit(TransactionWorkerEventsEnum.TransactionExecuted, data);
+        });
+        this.transactionWorker.on(TransactionWorkerEventsEnum.TransactionExecutionFailed, async (data) => {
+            this.emit(TransactionWorkerEventsEnum.TransactionExecutionFailed, data);
+        });
+        this.transactionWorker.on(TransactionWorkerEventsEnum.ExecutionFinish, async (data) => {
+            this.emit(TransactionWorkerEventsEnum.ExecutionFinish, data);
+        });
+    }
+    /**
+     * Send batch transactions for a single account.
+     *
+     * This function uses a transaction worker that receives payloads to be processed
+     * and submitted to chain.
+     * Note that this process is best for submitting multiple transactions that
+     * don't rely on each other, i.e. batch funds, batch token mints, etc.
+     *
+     * If any worker failure, the functions throws an error.
+     *
+     * @param args.sender The sender account to sign and submit the transaction
+     * @param args.data An array of transaction payloads
+     * @param args.options optional. Transaction generation configurations (excluding accountSequenceNumber)
+     *
+     * @return void. Throws if any error
+     * @group Implementation
+     */
+    forSingleAccount(args) {
+        try {
+            const { sender, data, options } = args;
+            this.start({ sender });
+            this.push({ data, options });
+        }
+        catch (error) {
+            throw new Error(`failed to submit transactions with error: ${error}`);
+        }
+    }
+}
+//# sourceMappingURL=management.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"management.js","sourceRoot":"","sources":["../../../src/api/transactionSubmission/management.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,117 @@
+import { Account } from "../../account/index.js";
+import { AccountAuthenticator, AnyRawTransaction } from "../../transactions/index.js";
+import { AptosConfig } from "../aptosConfig.js";
+/**
+ * A class to handle all `Sign` transaction operations.
+ *
+ * @param config - The configuration object for Aptos.
+ * @group Implementation
+ */
+export declare class Sign {
+    readonly config: AptosConfig;
+    /**
+     * Creates an instance of the Aptos client with the specified configuration.
+     *
+     * @param config - The configuration settings for the Aptos client.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * async function runExample() {
+     *     // Create a new Aptos client with testnet configuration
+     *     const config = new AptosConfig({ network: Network.TESTNET });
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client created with config:", config);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    constructor(config: AptosConfig);
+    /**
+     * Signs a transaction using the provided account signer. This function is essential for ensuring that transactions are properly
+     * authenticated before being sent to the network.
+     *
+     * @param args - The arguments for signing the transaction.
+     * @param args.signer - The account that will sign the transaction.
+     * @param args.transaction - The raw transaction data to be signed.
+     *
+     * @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 account for signing
+     *   const transaction = await aptos.transaction.build.simple({
+     *     sender: sender.accountAddress,
+     *     data: {
+     *       function: "0x1::aptos_account::transfer",
+     *       functionArguments: [ "0x1", 100 ], // replace with a real account address and amount
+     *     },
+     *   });
+     *
+     *   // Sign the transaction
+     *   const signedTransaction = await aptos.transaction.sign({
+     *     signer: sender,
+     *     transaction: transaction,
+     *   });
+     *
+     *   console.log("Signed Transaction:", signedTransaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    transaction(args: {
+        signer: Account;
+        transaction: AnyRawTransaction;
+    }): AccountAuthenticator;
+    /**
+     * Sets the fee payer address for a transaction and signs it with the provided account.
+     * This function is essential for transactions that require a designated fee payer.
+     *
+     * @param args - The arguments for the function.
+     * @param args.signer - The account that will sign the transaction.
+     * @param args.transaction - The transaction object that requires a fee payer address.
+     *
+     * @throws Error if the transaction does not have a feePayerAddress property.
+     *
+     * @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 account for signing
+     *   const transaction = await aptos.transaction.build.simple({
+     *     sender: sender.accountAddress,
+     *     data: {
+     *       function: "0x1::aptos_account::transfer",
+     *       functionArguments: ["0x1", 100], // replace with a real recipient address
+     *     },
+     *   });
+     *
+     *   // Set the fee payer for the transaction
+     *   transaction.feePayerAddress = "0x1"; // replace with a real fee payer address
+     *
+     *   const signedTransaction = await aptos.transactionAsFeePayer({ signer: sender, transaction });
+     *
+     *   console.log("Signed Transaction:", signedTransaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    transactionAsFeePayer(args: {
+        signer: Account;
+        transaction: AnyRawTransaction;
+    }): AccountAuthenticator;
+}
+//# sourceMappingURL=sign.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sign.d.ts","sourceRoot":"","sources":["../../../src/api/transactionSubmission/sign.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEjD,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACtF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;GAKG;AACH,qBAAa,IAAI;IACf,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAE7B;;;;;;;;;;;;;;;;;;;OAmBG;gBACS,MAAM,EAAE,WAAW;IAI/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IAEH,WAAW,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,WAAW,EAAE,iBAAiB,CAAA;KAAE,GAAG,oBAAoB;IAM5F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IAEH,qBAAqB,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,WAAW,EAAE,iBAAiB,CAAA;KAAE,GAAG,oBAAoB;CAiBvG"}

package/dist/api/transactionSubmission/sign.js

@@ -0,0 +1,130 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+import { signTransaction } from "../../internal/transactionSubmission.js";
+/**
+ * A class to handle all `Sign` transaction operations.
+ *
+ * @param config - The configuration object for Aptos.
+ * @group Implementation
+ */
+export class Sign {
+    config;
+    /**
+     * Creates an instance of the Aptos client with the specified configuration.
+     *
+     * @param config - The configuration settings for the Aptos client.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * async function runExample() {
+     *     // Create a new Aptos client with testnet configuration
+     *     const config = new AptosConfig({ network: Network.TESTNET });
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client created with config:", config);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Signs a transaction using the provided account signer. This function is essential for ensuring that transactions are properly
+     * authenticated before being sent to the network.
+     *
+     * @param args - The arguments for signing the transaction.
+     * @param args.signer - The account that will sign the transaction.
+     * @param args.transaction - The raw transaction data to be signed.
+     *
+     * @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 account for signing
+     *   const transaction = await aptos.transaction.build.simple({
+     *     sender: sender.accountAddress,
+     *     data: {
+     *       function: "0x1::aptos_account::transfer",
+     *       functionArguments: [ "0x1", 100 ], // replace with a real account address and amount
+     *     },
+     *   });
+     *
+     *   // Sign the transaction
+     *   const signedTransaction = await aptos.transaction.sign({
+     *     signer: sender,
+     *     transaction: transaction,
+     *   });
+     *
+     *   console.log("Signed Transaction:", signedTransaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    transaction(args) {
+        return signTransaction({
+            ...args,
+        });
+    }
+    /**
+     * Sets the fee payer address for a transaction and signs it with the provided account.
+     * This function is essential for transactions that require a designated fee payer.
+     *
+     * @param args - The arguments for the function.
+     * @param args.signer - The account that will sign the transaction.
+     * @param args.transaction - The transaction object that requires a fee payer address.
+     *
+     * @throws Error if the transaction does not have a feePayerAddress property.
+     *
+     * @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 account for signing
+     *   const transaction = await aptos.transaction.build.simple({
+     *     sender: sender.accountAddress,
+     *     data: {
+     *       function: "0x1::aptos_account::transfer",
+     *       functionArguments: ["0x1", 100], // replace with a real recipient address
+     *     },
+     *   });
+     *
+     *   // Set the fee payer for the transaction
+     *   transaction.feePayerAddress = "0x1"; // replace with a real fee payer address
+     *
+     *   const signedTransaction = await aptos.transactionAsFeePayer({ signer: sender, transaction });
+     *
+     *   console.log("Signed Transaction:", signedTransaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Implementation
+     */
+    transactionAsFeePayer(args) {
+        const { signer, transaction } = args;
+        // if transaction doesn't hold a "feePayerAddress" prop it means
+        // this is not a fee payer transaction
+        if (!transaction.feePayerAddress) {
+            throw new Error(`Transaction ${transaction} is not a Fee Payer transaction`);
+        }
+        // Set the feePayerAddress to the signer account address
+        transaction.feePayerAddress = signer.accountAddress;
+        return signTransaction({
+            signer,
+            transaction,
+        });
+    }
+}
+//# sourceMappingURL=sign.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sign.js","sourceRoot":"","sources":["../../../src/api/transactionSubmission/sign.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,sCAAsC;AAGtC,OAAO,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAI1E;;;;;GAKG;AACH,MAAM,OAAO,IAAI;IACN,MAAM,CAAc;IAE7B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,YAAY,MAAmB;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IAEH,WAAW,CAAC,IAAyD;QACnE,OAAO,eAAe,CAAC;YACrB,GAAG,IAAI;SACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IAEH,qBAAqB,CAAC,IAAyD;QAC7E,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;QAErC,gEAAgE;QAChE,sCAAsC;QACtC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,eAAe,WAAW,iCAAiC,CAAC,CAAC;QAC/E,CAAC;QAED,wDAAwD;QACxD,WAAW,CAAC,eAAe,GAAG,MAAM,CAAC,cAAc,CAAC;QAEpD,OAAO,eAAe,CAAC;YACrB,MAAM;YACN,WAAW;SACZ,CAAC,CAAC;IACL,CAAC;CACF"}

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

@@ -0,0 +1,176 @@
+import { PublicKey } from "../../core/index.js";
+import { AnyRawTransaction, InputSimulateTransactionOptions } from "../../transactions/index.js";
+import { UserTransactionResponse } from "../../types/index.js";
+import { AptosConfig } from "../aptosConfig.js";
+/**
+ * A class to handle all `Simulate` transaction operations.
+ * @group Implementation
+ */
+export declare class Simulate {
+    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.
+     *
+     * @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: AptosConfig);
+    /**
+     * 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
+     */
+    simple(args: {
+        signerPublicKey?: PublicKey;
+        transaction: AnyRawTransaction;
+        feePayerPublicKey?: PublicKey;
+        options?: InputSimulateTransactionOptions;
+    }): Promise<Array<UserTransactionResponse>>;
+    /**
+     * 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
+     */
+    multiAgent(args: {
+        signerPublicKey?: PublicKey;
+        transaction: AnyRawTransaction;
+        secondarySignersPublicKeys?: Array<PublicKey | undefined>;
+        feePayerPublicKey?: PublicKey;
+        options?: InputSimulateTransactionOptions;
+    }): Promise<Array<UserTransactionResponse>>;
+}
+//# sourceMappingURL=simulate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"simulate.d.ts","sourceRoot":"","sources":["../../../src/api/transactionSubmission/simulate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAE,iBAAiB,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AACjG,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD;;;GAGG;AACH,qBAAa,QAAQ;IACnB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAE7B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;gBACS,MAAM,EAAE,WAAW;IAI/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDG;IAEG,MAAM,CAAC,IAAI,EAAE;QACjB,eAAe,CAAC,EAAE,SAAS,CAAC;QAC5B,WAAW,EAAE,iBAAiB,CAAC;QAC/B,iBAAiB,CAAC,EAAE,SAAS,CAAC;QAC9B,OAAO,CAAC,EAAE,+BAA+B,CAAC;KAC3C,GAAG,OAAO,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IAI3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmEG;IAEG,UAAU,CAAC,IAAI,EAAE;QACrB,eAAe,CAAC,EAAE,SAAS,CAAC;QAC5B,WAAW,EAAE,iBAAiB,CAAC;QAC/B,0BAA0B,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;QAC1D,iBAAiB,CAAC,EAAE,SAAS,CAAC;QAC9B,OAAO,CAAC,EAAE,+BAA+B,CAAC;KAC3C,GAAG,OAAO,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;CAG5C"}