@aptos-labs/ts-sdk 6.3.1 → 7.0.0

package/dist/api/transaction.d.ts

@@ -0,0 +1,672 @@
+import { AptosConfig } from "./aptosConfig.js";
+import { AnyNumber, CommittedTransactionResponse, GasEstimation, HexInput, PaginationArgs, PendingTransactionResponse, TransactionResponse, WaitForTransactionOptions } from "../types/index.js";
+import { FeePayerOrFeePayerAuthenticatorOrNeither } from "../internal/transactionSubmission.js";
+import { AccountAuthenticator, AnyRawTransaction, InputGenerateTransactionOptions, InputGenerateTransactionPayloadData, InputTransactionPluginData } from "../transactions/index.js";
+import { AccountAddressInput, AccountPublicKey, Ed25519PrivateKey } from "../core/index.js";
+import { Account, Ed25519Account, MultiEd25519Account } from "../account/index.js";
+import { Build } from "./transactionSubmission/build.js";
+import { Simulate } from "./transactionSubmission/simulate.js";
+import { Submit } from "./transactionSubmission/submit.js";
+import { TransactionManagement } from "./transactionSubmission/management.js";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction.js";
+/**
+ * Represents a transaction in the Aptos blockchain,
+ * providing methods to build, simulate, submit, and manage transactions.
+ * This class encapsulates functionalities for querying transaction details,
+ * estimating gas prices, signing transactions, and handling transaction states.
+ *
+ * This class is used as part of the Aptos object, so should be called like so:
+ * @example
+ * ```typescript
+ * import { Account, Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+ *
+ * const ALICE_INITIAL_BALANCE = 100_000_000;
+ * const TRANSFER_AMOUNT = 100;
+ *
+ * async function example() {
+ *   console.log(
+ *     "This example will create two accounts (Alice and Bob), fund them, and transfer between them.",
+ *   );
+ *
+ *   // Set up the client
+ *   const config = new AptosConfig({ network: Network.DEVNET });
+ *   const aptos = new Aptos(config);
+ *
+ *   // Generate two account credentials
+ *   // Each account has a private key, a public key, and an address
+ *   const alice = Account.generate();
+ *   const bob = Account.generate();
+ *
+ *   console.log("=== Addresses ===\n");
+ *   console.log(`Alice's address is: ${alice.accountAddress}`);
+ *   console.log(`Bob's address is: ${bob.accountAddress}`);
+ *
+ *   // Fund the accounts using a faucet
+ *   console.log("\n=== Funding accounts ===\n");
+ *
+ *   await aptos.fundAccount({
+ *     accountAddress: alice.accountAddress,
+ *     amount: ALICE_INITIAL_BALANCE,
+ *   });
+ *
+ *   // Check initial balance
+ *   console.log("\n=== Initial Balance ===\n");
+ *   const aliceBalance = await aptos.getAccountAPTAmount({
+ *     accountAddress: alice.accountAddress,
+ *   });
+ *   console.log(`Alice's balance is: ${aliceBalance}`);
+ *
+ *   // Send a transaction from Alice's account to Bob's account
+ *   const txn = await aptos.transaction.build.simple({
+ *     sender: alice.accountAddress,
+ *     data: {
+ *       // All transactions on Aptos are implemented via smart contracts.
+ *       function: "0x1::aptos_account::transfer",
+ *       functionArguments: [bob.accountAddress, TRANSFER_AMOUNT],
+ *     },
+ *     options: { maxGasAmount: 100000 },
+ *   });
+ *
+ *   console.log("\n=== Transfer transaction ===\n");
+ *   // Both signs and submits
+ *   const committedTxn = await aptos.signAndSubmitTransaction({
+ *     signer: alice,
+ *     transaction: txn,
+ *   });
+ *   // Waits for Aptos to verify and execute the transaction
+ *   const executedTransaction = await aptos.waitForTransaction({
+ *     transactionHash: committedTxn.hash,
+ *   });
+ *   console.log("Transaction hash:", executedTransaction.hash);
+ *
+ *   console.log("\n=== Balances after transfer ===\n");
+ *   const newAliceBalance = await aptos.getAccountAPTAmount({
+ *     accountAddress: alice.accountAddress,
+ *   });
+ *   console.log(`Alice's balance is: ${newAliceBalance}`);
+ *
+ *   const newBobBalance = await aptos.getAccountAPTAmount({
+ *     accountAddress: bob.accountAddress,
+ *   });
+ *   console.log(`Bob's balance is: ${newBobBalance}`);
+ * }
+ *
+ * example();
+ * ```
+ * @group Transaction
+ */
+export declare class Transaction {
+    readonly config: AptosConfig;
+    readonly build: Build;
+    readonly simulate: Simulate;
+    readonly submit: Submit;
+    readonly batch: TransactionManagement;
+    /**
+     * Creates an 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 new Aptos client instance
+     *     const config = new AptosConfig({ network: Network.TESTNET }); // Specify the network
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client created successfully:", aptos);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    constructor(config: AptosConfig);
+    /**
+     * Queries on-chain transactions, excluding pending transactions.
+     * Use this function to retrieve historical transactions from the blockchain.
+     *
+     * @param args Optional parameters for pagination.
+     * @param args.options Optional pagination options.
+     * @param args.options.offset The number of the transaction to start with.
+     * @param args.options.limit The number of results to return.
+     *
+     * @returns An array of on-chain transactions.
+     *
+     * @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() {
+     *   // Fetch transactions with pagination
+     *   const transactions = await aptos.getTransactions({
+     *     options: {
+     *       offset: 0, // Start from the first transaction
+     *       limit: 10, // Limit to 10 results
+     *     },
+     *   });
+     *
+     *   console.log(transactions);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    getTransactions(args?: {
+        options?: PaginationArgs;
+    }): Promise<TransactionResponse[]>;
+    /**
+     * Queries on-chain transaction by version. This function will not return pending transactions.
+     *
+     * @param args - The arguments for querying the transaction.
+     * @param args.ledgerVersion - Transaction version is an unsigned 64-bit number.
+     * @returns On-chain transaction. Only on-chain transactions have versions, so this
+     * function cannot be used to query pending transactions.
+     *
+     * @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() {
+     *   // Fetching a transaction by its version
+     *   const transaction = await aptos.getTransactionByVersion({ ledgerVersion: 1 }); // replace 1 with a real version
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    getTransactionByVersion(args: {
+        ledgerVersion: AnyNumber;
+    }): Promise<TransactionResponse>;
+    /**
+     * Queries on-chain transactions by their transaction hash, returning both pending and committed transactions.
+     *
+     * @param args - The arguments for querying the transaction.
+     * @param args.transactionHash - The transaction hash should be a hex-encoded bytes string with a 0x prefix.
+     * @returns The transaction from the mempool (pending) or the on-chain (committed) transaction.
+     *
+     * @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() {
+     *   // Fetch a transaction by its hash
+     *   const transaction = await aptos.getTransactionByHash({ transactionHash: "0x123" }); // replace with a real transaction hash
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    getTransactionByHash(args: {
+        transactionHash: HexInput;
+    }): Promise<TransactionResponse>;
+    /**
+     * Defines if the specified transaction is currently in a pending state.
+     * This function helps you determine the status of a transaction using its hash.
+     *
+     * @param args - The arguments for the function.
+     * @param args.transactionHash - A hash of the transaction in hexadecimal format.
+     * @returns `true` if the transaction is in a pending state and `false` otherwise.
+     *
+     * @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() {
+     *   // Check if the transaction is pending using its hash
+     *   const isPendingTransaction = await aptos.isPendingTransaction({ transactionHash: "0x123" }); // replace with a real transaction hash
+     *   console.log("Is the transaction pending?", isPendingTransaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    isPendingTransaction(args: {
+        transactionHash: HexInput;
+    }): Promise<boolean>;
+    /**
+     * Waits for a transaction to move past the pending state and provides the transaction response.
+     * There are 4 cases.
+     * 1. Transaction is successfully processed and committed to the chain.
+     *    - The function will resolve with the transaction response from the API.
+     * 2. Transaction is rejected for some reason, and is therefore not committed to the blockchain.
+     *    - The function will throw an AptosApiError with an HTTP status code indicating some problem with the request.
+     * 3. Transaction is committed but execution failed, meaning no changes were
+     *    written to the blockchain state.
+     *    - If `checkSuccess` is true, the function will throw a FailedTransactionError
+     *      If `checkSuccess` is false, the function will resolve with the transaction response where the `success` field is false.
+     * 4. Transaction does not move past the pending state within `args.options.timeoutSecs` seconds.
+     *    - The function will throw a WaitForTransactionError
+     *
+     * @param args.transactionHash - The hash of a transaction previously submitted to the blockchain.
+     * @param args.options - Optional parameters for waiting behavior.
+     * @param args.options.timeoutSecs - Timeout in seconds. Defaults to 20 seconds.
+     * @param args.options.checkSuccess - A boolean which controls whether the function will error if the transaction failed.
+     * Defaults to true.
+     * @returns The transaction on-chain response.
+     *
+     * @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() {
+     *   // Wait for a transaction to complete using its hash
+     *   const transactionHash = "0x123"; // replace with a real transaction hash
+     *   const transactionResponse = await aptos.waitForTransaction({
+     *     transactionHash,
+     *     options: {
+     *       timeoutSecs: 30, // specify your own timeout if needed
+     *       checkSuccess: true,
+     *     },
+     *   });
+     *
+     *   console.log(transactionResponse);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    waitForTransaction(args: {
+        transactionHash: HexInput;
+        options?: WaitForTransactionOptions;
+    }): Promise<CommittedTransactionResponse>;
+    /**
+     * Estimates the gas unit price required to process a transaction on the Aptos blockchain in a timely manner.
+     * This helps users to understand the cost associated with their transactions.
+     * {@link https://api.mainnet.aptoslabs.com/v1/spec#/operations/estimate_gas_price}
+     *
+     * @returns An object containing the estimated gas price.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET }); // Specify your network
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Getting the gas price estimation
+     *   const gasPriceEstimation = await aptos.getGasPriceEstimation();
+     *
+     *   console.log("Estimated Gas Price:", gasPriceEstimation);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    getGasPriceEstimation(): Promise<GasEstimation>;
+    /**
+     * Returns a signing message for a transaction, allowing a user to sign it using their preferred method before submission to the network.
+     *
+     * @param args - The arguments for obtaining the signing message.
+     * @param args.transaction - A raw transaction for signing elsewhere.
+     *
+     * @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() {
+     *     const transaction = await aptos.transaction.build.simple({
+     *         sender: "0x1", // replace with a real sender address
+     *         data: {
+     *             function: "0x1::aptos_account::transfer",
+     *             functionArguments: ["0x2", 100], // replace with a real destination address
+     *         },
+     *     });
+     *
+     *     const message = await aptos.getSigningMessage({ transaction });
+     *     console.log(message);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    getSigningMessage(args: {
+        transaction: AnyRawTransaction;
+    }): Uint8Array;
+    /**
+     * Generates a transaction to publish a Move package to the blockchain.
+     * This function helps you create a transaction that can be simulated or submitted to the chain for publishing a package.
+     *
+     * To get the `metadataBytes` and `byteCode`, can compile using Aptos CLI with command
+     * `aptos move compile --save-metadata ...`,
+     *
+     * {@link https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module}
+     *
+     * @param args The arguments for publishing the package.
+     * @param args.account The publisher account.
+     * @param args.metadataBytes The package metadata bytes.
+     * @param args.moduleBytecode An array of the bytecode of each module in the package in compiler output order.
+     * @param args.options Optional settings for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @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() {
+     *   // Replace with a real account address
+     *   const account = "0x1";
+     *   const metadataBytes = "0x..."; // replace with real metadata bytes
+     *   const byteCode = "0x..."; // replace with real module bytecode
+     *
+     *   const transaction = await aptos.publishPackageTransaction({
+     *     account,
+     *     metadataBytes,
+     *     moduleBytecode: [byteCode],
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    publishPackageTransaction(args: {
+        account: AccountAddressInput;
+        metadataBytes: HexInput;
+        moduleBytecode: Array<HexInput>;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Rotates the authentication key for a given account.  Once an account is rotated, only the new private key
+     * or keyless signing scheme can be used to sign transactions for the account.
+     *
+     * @param args - The arguments for rotating the authentication key.
+     * @param args.fromAccount - The account from which the authentication key will be rotated.
+     * @param args.toAccount - (Optional) The target account to rotate to. Required if not using toNewPrivateKey.
+     * @param args.toNewPrivateKey - (Optional) The new private key to rotate to. Required if not using toAccount.
+     *
+     * @remarks
+     * This function supports three modes of rotation:
+     * 1. Using a target Account object (toAccount)
+     * 2. Using a new private key (toNewPrivateKey)
+     *
+     * For Ed25519 accounts, the function will use a challenge-based rotation that requires signatures from both the old and new keys.
+     * For multi-key accounts like MultiEd25519Account, the function will use a challenge-based rotation that requires signatures from both keys.
+     * For other account types, the function will use an unverified rotation that only requires the new public key.
+     *
+     * @returns SimpleTransaction that can be submitted to rotate the auth key
+     *
+     * @example
+     * ```typescript
+     * // Create and submit transaction to rotate the auth key
+     * const transaction = await aptos.rotateAuthKey({
+     *   fromAccount,
+     *   toAccount: toAccount,
+     * });
+     *
+     * // Sign and submit the transaction
+     * const pendingTransaction = await aptos.signAndSubmitTransaction({
+     *   signer: fromAccount,
+     *   transaction,
+     * });
+     * ```
+     * @group Transaction
+     */
+    rotateAuthKey(args: {
+        fromAccount: Account;
+        options?: InputGenerateTransactionOptions;
+    } & ({
+        toAccount: Ed25519Account | MultiEd25519Account;
+    } | {
+        toNewPrivateKey: Ed25519PrivateKey;
+    })): Promise<SimpleTransaction>;
+    /**
+     * Rotates the authentication key for a given account without verifying the new key.
+     *
+     * Accounts with their auth key rotated via this function will be derivable via the `getAccountsForPublicKey` and
+     * `deriveOwnedAccountsFromSigner` functions however the public key will be unverified (no proof of ownership). Thus
+     * includeUnverified must be set to true to derive the account until the public key is verified via signing a transaction.
+     *
+     * @param args - The arguments for rotating the authentication key.
+     * @param args.fromAccount - The account from which the authentication key will be rotated.
+     * @param args.toNewPublicKey - The new public key to rotate to.
+     *
+     * @returns A simple transaction object that can be submitted to the network.
+     *
+     * @example
+     * ```typescript
+     * // Create and submit transaction to rotate the auth key
+     * const transaction = await aptos.rotateAuthKeyUnverified({
+     *   fromAccount,
+     *   toNewPublicKey,
+     * });
+     *
+     * // Sign and submit the transaction
+     * const pendingTransaction = await aptos.signAndSubmitTransaction({
+     *   signer: fromAccount,
+     *   transaction,
+     * });
+     * ```
+     * @group Transaction
+     */
+    rotateAuthKeyUnverified(args: {
+        fromAccount: Account;
+        options?: InputGenerateTransactionOptions;
+        toNewPublicKey: AccountPublicKey;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Sign a transaction that can later be submitted to the chain.
+     * This function is essential for ensuring the authenticity of the transaction by using the provided account's signing capabilities.
+     *
+     * @param args - The arguments for signing the transaction.
+     * @param args.signer - The account that will sign the transaction.
+     * @param args.transaction - A raw transaction to sign.
+     *
+     * @returns AccountAuthenticator - The authenticator for the signed transaction.
+     *
+     * @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() {
+     *   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
+     *     },
+     *   });
+     *
+     *   const signedTransaction = await aptos.transaction.sign({
+     *     signer: sender,
+     *     transaction,
+     *   }); // Sign the transaction
+     *
+     *   console.log("Signed Transaction:", signedTransaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    sign(args: {
+        signer: Account;
+        transaction: AnyRawTransaction;
+    }): AccountAuthenticator;
+    /**
+     * Sign a transaction as a fee payer that can later be submitted to the chain.
+     * This function ensures that the transaction is marked with the fee payer's address, allowing it to be processed correctly.
+     *
+     * @param args - The arguments for signing the transaction.
+     * @param args.signer - The fee payer signer account.
+     * @param args.transaction - A raw transaction to sign on. This transaction must include a `feePayerAddress` property.
+     *
+     * @returns AccountAuthenticator - The authenticator for the signed transaction.
+     *
+     * @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() {
+     *   const sender = Account.generate(); // Generate a new account for the fee payer
+     *   const transaction = await aptos.transaction.build.simple({
+     *     // All transactions on Aptos are implemented via smart contracts.
+     *     function: "0x1::aptos_account::transfer",
+     *     functionArguments: [sender.accountAddress, 100],
+     *     feePayerAddress: sender.accountAddress, // Set the fee payer address
+     *   });
+     *
+     *   const signedTransaction = await aptos.transaction.signAsFeePayer({
+     *     signer: sender,
+     *     transaction,
+     *   });
+     *
+     *   console.log("Signed transaction as fee payer:", signedTransaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    signAsFeePayer(args: {
+        signer: Account;
+        transaction: AnyRawTransaction;
+    }): AccountAuthenticator;
+    /**
+     * @deprecated Prefer to use `aptos.transaction.batch.forSingleAccount()`
+     *
+     * Batch transactions for a single account by submitting multiple transaction payloads.
+     * This function is useful for efficiently processing and submitting transactions that do not depend on each other, such as
+     * batch funding or batch token minting.
+     *
+     * @param args - The arguments for batching transactions.
+     * @param args.sender - The sender account to sign and submit the transactions.
+     * @param args.data - An array of transaction payloads to be processed.
+     * @param args.options - Optional. Transaction generation configurations (excluding accountSequenceNumber).
+     *
+     * @throws Error if any worker failure occurs during submission.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     * const sender = Account.generate(); // Generate a new account for sending transactions
+     *
+     * async function runExample() {
+     *   const transactions = [
+     *     { }, // Build your first transaction payload
+     *     { }, // Build your second transaction payload
+     *   ];
+     *
+     *   // Batch transactions for the single account
+     *   await aptos.batchTransactionsForSingleAccount({
+     *     sender,
+     *     data: transactions,
+     *   });
+     *
+     *   console.log("Batch transactions submitted successfully.");
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Transaction
+     */
+    batchTransactionsForSingleAccount(args: {
+        sender: Account;
+        data: InputGenerateTransactionPayloadData[];
+        options?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">;
+    }): Promise<void>;
+    /**
+     * Sign and submit a single signer transaction to the blockchain.
+     * This function allows you to execute a transaction after signing it with the specified account.
+     *
+     * @param args The arguments for signing and submitting the transaction.
+     * @param args.signer The signer account to sign the transaction.
+     * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses.
+     *
+     * @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() {
+     *   const sender = Account.generate(); // Generate a new account for sending the transaction
+     *   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
+     *     },
+     *   });
+     *
+     *   // Sign and submit the transaction
+     *   const pendingTransaction = await aptos.signAndSubmitTransaction({
+     *     signer: sender,
+     *     transaction,
+     *   });
+     *
+     *   console.log(pendingTransaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @return PendingTransactionResponse
+     * @group Transaction
+     */
+    signAndSubmitTransaction(args: FeePayerOrFeePayerAuthenticatorOrNeither & {
+        signer: Account;
+        transaction: AnyRawTransaction;
+    } & InputTransactionPluginData): Promise<PendingTransactionResponse>;
+    /**
+     * Sign and submit a single signer transaction as the fee payer to chain given an authenticator by the sender of the transaction.
+     *
+     * @param args.feePayer The fee payer account to sign the transaction
+     * @param args.senderAuthenticator The AccountAuthenticator signed by the sender of the transaction
+     * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
+     *
+     * @example
+     * const transaction = await aptos.transaction.build.simple({sender: alice.accountAddress, feePayer: true ...})
+     * const senderAuthenticator = alice.signTransactionWithAuthenticator(transaction)
+     * const pendingTransaction = await aptos.signAndSubmitAsFeePayer({
+     *  senderAuthenticator,
+     *  feePayer: bob,
+     *  transaction,
+     * })
+     *
+     * @return PendingTransactionResponse
+     * @group Transaction
+     */
+    signAndSubmitAsFeePayer(args: {
+        feePayer: Account;
+        senderAuthenticator: AccountAuthenticator;
+        transaction: AnyRawTransaction;
+    } & InputTransactionPluginData): Promise<PendingTransactionResponse>;
+}
+//# sourceMappingURL=transaction.d.ts.map

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

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