Class Transaction

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

import { Account, Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";

const APTOS_COIN = "0x1::aptos_coin::AptosCoin";
const COIN_STORE = `0x1::coin::CoinStore<${APTOS_COIN}>`;
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,
  });

  // 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, 100],
    },
  });

  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 newAliceAccountBalance = await aptos.getAccountResource({
   accountAddress: alice.accountAddress,
   resourceType: COIN_STORE,
 });
 const newAliceBalance = Number(newAliceAccountBalance.coin.value);
 console.log(`Alice's balance is: ${newAliceBalance}`);

 const newBobAccountBalance = await aptos.getAccountResource({
   accountAddress: bob.accountAddress,
   resourceType: COIN_STORE,
 });
 const newBobBalance = Number(newBobAccountBalance.coin.value);
 console.log(`Bob's balance is: ${newBobBalance}`);
}

example();

Properties

`Readonly`batch

batch: TransactionManagement

`Readonly`build

build: Build

`Readonly`config

config: AptosConfig

`Readonly`simulate

simulate: Simulate

`Readonly`submit

submit: Submit

Transaction

constructor

new Transaction(config): Transaction

Creates an instance of the Aptos client with the specified configuration. This allows you to interact with the Aptos blockchain using the provided settings.

Parameters

config: AptosConfig
The configuration settings for the Aptos client.

Returns Transaction

Example

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);

batchTransactionsForSingleAccount

batchTransactionsForSingleAccount(args): Promise<void>
Parameters
- args: {
      data: InputGenerateTransactionPayloadData[];
      options?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">;
      sender: Account;
  }
  The arguments for batching transactions.
  - data: InputGenerateTransactionPayloadData[]
    An array of transaction payloads to be processed.
  - Optionaloptions?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">
    Optional. Transaction generation configurations (excluding accountSequenceNumber).
  - sender: Account
    The sender account to sign and submit the transactions.
Returns Promise<void>
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.

Throws
Error if any worker failure occurs during submission.
Example
```
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);
```
- Defined in src/api/transaction.ts:644

getGasPriceEstimation

getGasPriceEstimation(): Promise<GasEstimation>

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. https://api.mainnet.aptoslabs.com/v1/spec#/operations/estimate_gas_price

Returns Promise<GasEstimation>

An object containing the estimated gas price.

Example

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);

getSigningMessage

getSigningMessage(args): Uint8Array

Returns a signing message for a transaction, allowing a user to sign it using their preferred method before submission to the network.

Parameters

args: {
transaction: AnyRawTransaction;
}
The arguments for obtaining the signing message.
- transaction: AnyRawTransaction
  A raw transaction for signing elsewhere.

Returns Uint8Array

Example

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);

getTransactionByHash

getTransactionByHash(args): Promise<TransactionResponse>
Queries on-chain transactions by their transaction hash, returning both pending and committed transactions.
Parameters
- args: {
  transactionHash: HexInput;
  }
  The arguments for querying the transaction.
  - transactionHash: HexInput
    The transaction hash should be a hex-encoded bytes string with a 0x prefix.
Returns Promise<TransactionResponse>
The transaction from the mempool (pending) or the on-chain (committed) transaction.
Example
```
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);
```
- Defined in src/api/transaction.ts:268

getTransactionByVersion

getTransactionByVersion(args): Promise<TransactionResponse>
Queries on-chain transaction by version. This function will not return pending transactions.
Parameters
- args: {
  ledgerVersion: AnyNumber;
  }
  The arguments for querying the transaction.
  - ledgerVersion: AnyNumber
    Transaction version is an unsigned 64-bit number.
Returns Promise<TransactionResponse>
On-chain transaction. Only on-chain transactions have versions, so this function cannot be used to query pending transactions.
Example
```
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);
```
- Defined in src/api/transaction.ts:237

getTransactions

getTransactions(args?): Promise<TransactionResponse[]>

Queries on-chain transactions, excluding pending transactions. Use this function to retrieve historical transactions from the blockchain.

Parameters

Optionalargs: {
options?: PaginationArgs;
}
Optional parameters for pagination.
- Optionaloptions?: PaginationArgs
  Optional pagination options.

Returns Promise<TransactionResponse[]>

An array of on-chain transactions.

Example

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);

isPendingTransaction

isPendingTransaction(args): Promise<boolean>

Defines if the specified transaction is currently in a pending state. This function helps you determine the status of a transaction using its hash.

Parameters

args: {
transactionHash: HexInput;
}
The arguments for the function.
- transactionHash: HexInput
  A hash of the transaction in hexadecimal format.

Returns Promise<boolean>

true if the transaction is in a pending state and false otherwise.

Example

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);

publishPackageTransaction

publishPackageTransaction(args): Promise<SimpleTransaction>
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 ...,

https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module
Parameters
- args: {
      account: AccountAddressInput;
      metadataBytes: HexInput;
      moduleBytecode: HexInput[];
      options?: InputGenerateTransactionOptions;
  }
  The arguments for publishing the package.
  - account: AccountAddressInput
    The publisher account.
  - metadataBytes: HexInput
    The package metadata bytes.
  - moduleBytecode: HexInput[]
    An array of the bytecode of each module in the package in compiler output order.
  - Optionaloptions?: InputGenerateTransactionOptions
    Optional settings for generating the transaction.
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
Example
```
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);
```
- Defined in src/api/transaction.ts:467

rotateAuthKey

rotateAuthKey(args): Promise<TransactionResponse>

Rotate an account's authentication key. After rotation, only the new private key can be used to sign transactions for the account. Note: Only legacy Ed25519 scheme is supported for now. More info: https://aptos.dev/guides/account-management/key-rotation/

Parameters

args: {
fromAccount: Account;
toNewPrivateKey: PrivateKeyInput;
}
The arguments for rotating the auth key.
- fromAccount: Account
  The account to rotate the auth key for.
- toNewPrivateKey: PrivateKeyInput
  The new private key to rotate to.

Returns Promise<TransactionResponse>

PendingTransactionResponse

Example

import { Aptos, AptosConfig, Network, Account, PrivateKey } from "@aptos-labs/ts-sdk";

const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);

async function runExample() {
  // Rotate the authentication key for an account
  const response = await aptos.rotateAuthKey({
    // replace with a real account
    fromAccount: Account.generate(),
    // replace with a real private key
    toNewPrivateKey: new PrivateKey("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"),
  });

  console.log(response);
}
runExample().catch(console.error);

sign

sign(args): AccountAuthenticator

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.

Parameters

args: {
signer: Account;
transaction: AnyRawTransaction;
}
The arguments for signing the transaction.
- signer: Account
  The account that will sign the transaction.
- transaction: AnyRawTransaction
  A raw transaction to sign.

Returns AccountAuthenticator

AccountAuthenticator - The authenticator for the signed transaction.

Example

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);

signAndSubmitAsFeePayer

signAndSubmitAsFeePayer(args): Promise<PendingTransactionResponse>
Sign and submit a single signer transaction as the fee payer to chain given an authenticator by the sender of the transaction.
Parameters
- args: {
      feePayer: Account;
      senderAuthenticator: AccountAuthenticator;
      transaction: AnyRawTransaction;
  }
  - feePayer: Account
    The fee payer account to sign the transaction
  - senderAuthenticator: AccountAuthenticator
    The AccountAuthenticator signed by the sender of the transaction
  - transaction: AnyRawTransaction
    An instance of a RawTransaction, plus optional secondary/fee payer addresses
Returns Promise<PendingTransactionResponse>
PendingTransactionResponse
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,
})
```
- Defined in src/api/transaction.ts:726

signAndSubmitTransaction

signAndSubmitTransaction(args): Promise<PendingTransactionResponse>

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.

Parameters

args: FeePayerOrFeePayerAuthenticatorOrNeither & {
signer: Account;
transaction: AnyRawTransaction;
}
The arguments for signing and submitting the transaction.

Returns Promise<PendingTransactionResponse>

PendingTransactionResponse

Example

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);

signAsFeePayer

signAsFeePayer(args): 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.

Parameters

args: {
signer: Account;
transaction: AnyRawTransaction;
}
The arguments for signing the transaction.
- signer: Account
  The fee payer signer account.
- transaction: AnyRawTransaction
  A raw transaction to sign on. This transaction must include a feePayerAddress property.

Returns AccountAuthenticator

AccountAuthenticator - The authenticator for the signed transaction.

Example

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);

waitForTransaction

waitForTransaction(args): Promise<CommittedTransactionResponse>
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
Parameters
- args: {
  options?: WaitForTransactionOptions;
  transactionHash: HexInput;
  }
  - Optionaloptions?: WaitForTransactionOptions
    Optional parameters for waiting behavior.
  - transactionHash: HexInput
    The hash of a transaction previously submitted to the blockchain.
Returns Promise<CommittedTransactionResponse>
The transaction on-chain response.
Example
```
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);
```
- Defined in src/api/transaction.ts:351

Class Transaction

Example

Index

Properties

Transaction

Properties

Readonlybatch

Readonlybuild

Readonlyconfig

Readonlysimulate

Readonlysubmit

Transaction

constructor

Parameters

Returns Transaction

Example

batchTransactionsForSingleAccount

Parameters

data: InputGenerateTransactionPayloadData[]

Optionaloptions?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">

sender: Account

Returns Promise<void>

Deprecated

Throws

Example

getGasPriceEstimation

Returns Promise<GasEstimation>

Example

getSigningMessage

Parameters

transaction: AnyRawTransaction

Returns Uint8Array

Example

getTransactionByHash

Parameters

transactionHash: HexInput

Returns Promise<TransactionResponse>

Example

getTransactionByVersion

Parameters

ledgerVersion: AnyNumber

Returns Promise<TransactionResponse>

Example

getTransactions

Parameters

Optionaloptions?: PaginationArgs

Returns Promise<TransactionResponse[]>

Example

isPendingTransaction

Parameters

transactionHash: HexInput

Returns Promise<boolean>

Example

publishPackageTransaction

Parameters

account: AccountAddressInput

metadataBytes: HexInput

moduleBytecode: HexInput[]

Optionaloptions?: InputGenerateTransactionOptions

Returns Promise<SimpleTransaction>

Example

rotateAuthKey

Parameters

fromAccount: Account

toNewPrivateKey: PrivateKeyInput

Returns Promise<TransactionResponse>

Example

sign

Parameters

signer: Account

transaction: AnyRawTransaction

Returns AccountAuthenticator

Example

signAndSubmitAsFeePayer

Parameters

feePayer: Account

senderAuthenticator: AccountAuthenticator

transaction: AnyRawTransaction

Returns Promise<PendingTransactionResponse>

Example

`Readonly`batch

`Readonly`build

`Readonly`config

`Readonly`simulate

`Readonly`submit

`Optional`options?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">

`Optional`options?: PaginationArgs

`Optional`options?: InputGenerateTransactionOptions

`Optional`options?: WaitForTransactionOptions