⚠️Blast API (blastapi.io) ends Oct 31. Migrate to Dwellir and skip Alchemy's expensive compute units.
Switch Today →
Skip to main content

Orderless Transactions

Orderless transactions on Aptos reduce head-of-line blocking by allowing flexible transaction ordering using explicit nonces instead of strict sequence numbers. This feature enables parallel transaction submission and improves throughput for accounts issuing multiple independent operations simultaneously.

Overview#

Traditional blockchain accounts process transactions in strict sequential order based on sequence numbers, where transaction N+1 cannot execute until transaction N completes. Orderless transactions relax this constraint by using nonces that allow transactions to execute in any order when dependencies permit, significantly improving performance for high-frequency accounts like exchanges, bots, and payment processors.

How It Works#

Instead of requiring sequential processing, orderless transactions use nonces to indicate independence:

// Traditional: Must execute in order 0, 1, 2, 3...
Transaction { sequence_number: 0 }
Transaction { sequence_number: 1 }  // Blocks on 0
Transaction { sequence_number: 2 }  // Blocks on 1

// Orderless: Can execute in any order
Transaction { nonce: 1 }  // Independent
Transaction { nonce: 2 }  // Independent
Transaction { nonce: 3 }  // Independent

Implementation#

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

const aptos = new Aptos();
const account = Account.generate();

// Submit multiple transactions with different nonces
const nonce1 = 100;
const nonce2 = 101;
const nonce3 = 102;

// All can execute in parallel
const tx1 = await aptos.transaction.build.simple({
  sender: account.accountAddress,
  data: {
    function: "0x1::coin::transfer",
    functionArguments: [recipient1, 1000]
  },
  options: { nonce: nonce1 }
});

const tx2 = await aptos.transaction.build.simple({
  sender: account.accountAddress,
  data: {
    function: "0x1::coin::transfer",
    functionArguments: [recipient2, 2000]
  },
  options: { nonce: nonce2 }
});

// Submit both immediately
await aptos.transaction.submit.simple({ transaction: tx1, senderAuthenticator: auth1 });
await aptos.transaction.submit.simple({ transaction: tx2, senderAuthenticator: auth2 });

Real-World Use Cases#

  1. Exchange Operations: Crypto exchanges can submit thousands of withdrawal transactions simultaneously without waiting for sequential processing, dramatically increasing throughput.

  2. Payment Processors: Payment platforms can process multiple customer payments in parallel rather than queuing them sequentially.

  3. Bot Operations: Trading bots and automated market makers can submit multiple independent transactions without head-of-line blocking from slower operations.

  4. Batch Processing: Applications can submit large batches of independent transactions that execute as capacity permits rather than in strict order.

  5. Multi-User Services: Services managing operations for multiple users can interleave transactions without artificial ordering constraints.

  6. Retry Logic: Failed transactions can be retried with new nonces while other transactions continue processing without blocking.

Best Practices#

Use Unique Nonces: Ensure each transaction from an account uses a unique nonce to prevent conflicts and rejections.

Track Nonce Usage: Maintain a nonce counter or registry to avoid accidentally reusing nonces across concurrent operations.

Handle Race Conditions: Implement proper error handling for nonce conflicts that may occur in distributed systems.

Monitor Nonce Gaps: Track which nonces have been used to identify failed or pending transactions.

Set Reasonable Limits: Don't create excessive nonce gaps as validators may have limits on nonce range acceptance.

Combine with Sequence Numbers: Use orderless transactions for truly independent operations while using sequence numbers for dependent chains.

Limitations#

  • Nonces must be managed carefully to avoid conflicts
  • Not all transaction types support orderless execution
  • May require changes to existing transaction submission infrastructure
  • Validators may impose limits on maximum nonce values or gaps
  • Ordering guarantees between transactions are reduced

Comparison with Sequential Transactions#

Sequential (Traditional)

  • Guaranteed execution order
  • Simpler to reason about dependencies
  • Natural retry semantics
  • Lower throughput under load

Orderless (Nonce-based)

  • Higher throughput potential
  • Parallel execution capability
  • More complex nonce management
  • Better for independent operations

Monitoring and Debugging#

// Track nonce usage
const usedNonces = new Set<number>();

function getNextNonce(): number {
  let nonce = Math.floor(Math.random() * 1000000);
  while (usedNonces.has(nonce)) {
    nonce = Math.floor(Math.random() * 1000000);
  }
  usedNonces.add(nonce);
  return nonce;
}

// Check transaction status by nonce
async function checkNonceStatus(account: address, nonce: number) {
  // Query blockchain for transaction with specific nonce
}