Transaction Search

← Back to Indexer Client

Description

This example demonstrates how to search for transactions with various filters using the IndexerClient searchForTransactions() method.

Prerequisites

• LocalNet running (via algokit localnet start)

Run This Example

From the repository root:

cd examples
npm run example indexer_client/07-transaction-search.ts

Code

View source on GitHub

07-transaction-search.ts

/**
 * Example: Transaction Search
 *
 * This example demonstrates how to search for transactions with various filters using
 * the IndexerClient searchForTransactions() method.
 *
 * Prerequisites:
 * - LocalNet running (via `algokit localnet start`)
 */

import { algo } from '@algorandfoundation/algokit-utils';
import {
  assignFee,
  OnApplicationComplete,
  Transaction,
  TransactionType,
  type AppCallTransactionFields,
} from '@algorandfoundation/algokit-utils/transact';
import {
  createAlgodClient,
  createAlgorandClient,
  createIndexerClient,
  formatMicroAlgo,
  loadTealSource,
  printError,
  printHeader,
  printInfo,
  printStep,
  printSuccess,
  shortenAddress,
} from '../shared/utils.js';

/**
 * Wait for a transaction to be confirmed
 */
async function waitForConfirmation(
  algod: ReturnType<typeof createAlgodClient>,
  txId: string,
  maxRounds = 10,
): Promise<Record<string, unknown>> {
  let lastRound = (await algod.status()).lastRound;
  const startRound = lastRound;

  while (lastRound < startRound + BigInt(maxRounds)) {
    const pendingInfo = await algod.pendingTransactionInformation(txId);
    if (pendingInfo.confirmedRound && pendingInfo.confirmedRound > 0n) {
      return pendingInfo as Record<string, unknown>;
    }
    lastRound = (await algod.statusAfterBlock(lastRound)).lastRound;
  }

  throw new Error(`Transaction ${txId} not confirmed after ${maxRounds} rounds`);
}

async function main() {
  printHeader('Transaction Search Example');

  // Create clients
  const indexer = createIndexerClient();
  const algorand = createAlgorandClient();
  const algod = createAlgodClient();

  // =========================================================================
  // Step 1: Get a funded account from LocalNet
  // =========================================================================
  printStep(1, 'Getting a funded account from LocalNet');

  let senderAddress: string;
  let senderAccount: Awaited<ReturnType<typeof algorand.account.kmd.getLocalNetDispenserAccount>>;

  try {
    senderAccount = await algorand.account.kmd.getLocalNetDispenserAccount();
    algorand.setSignerFromAccount(senderAccount);
    senderAddress = senderAccount.addr.toString();
    printSuccess(`Using dispenser account: ${shortenAddress(senderAddress)}`);
  } catch (error) {
    printError(
      `Failed to get dispenser account: ${error instanceof Error ? error.message : String(error)}`,
    );
    printInfo('');
    printInfo('Make sure LocalNet is running: algokit localnet start');
    printInfo('If issues persist, try: algokit localnet reset');
    return;
  }

  // =========================================================================
  // Step 2: Create several different transaction types for setup
  // =========================================================================
  printStep(2, 'Creating several different transaction types for setup');

  let receiverAddress: string;
  let assetId: bigint;
  let appId: bigint;
  let startRound: bigint;

  try {
    // Get the current round before creating transactions
    const status = await algod.status();
    startRound = status.lastRound;

    // Create a random receiver account
    const receiverAccount = algorand.account.random();
    receiverAddress = receiverAccount.addr.toString();
    algorand.setSignerFromAccount(receiverAccount);
    printInfo(`Created receiver account: ${shortenAddress(receiverAddress)}`);

    // 1. Payment transaction
    printInfo('Creating payment transaction...');
    await algorand.send.payment({
      sender: senderAccount.addr,
      receiver: receiverAccount.addr,
      amount: algo(10),
    });
    printSuccess('Payment sent: 10 ALGO');

    // 2. Another payment with different amount
    printInfo('Creating another payment transaction...');
    await algorand.send.payment({
      sender: senderAccount.addr,
      receiver: receiverAccount.addr,
      amount: algo(5),
    });
    printSuccess('Payment sent: 5 ALGO');

    // 3. Asset creation (acfg transaction)
    printInfo('Creating asset config transaction (asset creation)...');
    const assetCreateResult = await algorand.send.assetCreate({
      sender: senderAccount.addr,
      total: 1_000_000n,
      decimals: 6,
      assetName: 'SearchTestToken',
      unitName: 'SRCH',
    });
    assetId = assetCreateResult.assetId;
    printSuccess(`Created asset: SearchTestToken (ID: ${assetId})`);

    // 4. Asset opt-in (axfer to self with 0 amount)
    printInfo('Creating asset opt-in transaction...');
    await algorand.send.assetOptIn({
      sender: receiverAccount.addr,
      assetId: assetId,
    });
    printSuccess('Receiver opted into asset');

    // 5. Asset transfer (axfer)
    printInfo('Creating asset transfer transaction...');
    await algorand.send.assetTransfer({
      sender: senderAccount.addr,
      receiver: receiverAccount.addr,
      assetId: assetId,
      amount: 50_000n,
    });
    printSuccess('Asset transfer sent: 50,000 units');

    // 6. Application creation (appl transaction)
    printInfo('Creating application transaction...');
    // Load simple approval/clear programs from shared artifacts
    const approvalSource = loadTealSource('clear-state-approve.teal');
    const clearSource = loadTealSource('clear-state-approve.teal');

    const approvalResult = await algod.tealCompile(approvalSource);
    const approvalProgram = new Uint8Array(Buffer.from(approvalResult.result, 'base64'));

    const clearResult = await algod.tealCompile(clearSource);
    const clearStateProgram = new Uint8Array(Buffer.from(clearResult.result, 'base64'));

    const suggestedParams = await algod.suggestedParams();

    const appCallFields: AppCallTransactionFields = {
      appId: 0n,
      onComplete: OnApplicationComplete.NoOp,
      approvalProgram,
      clearStateProgram,
      globalStateSchema: { numUints: 0, numByteSlices: 0 },
      localStateSchema: { numUints: 0, numByteSlices: 0 },
    };

    const createAppTx = new Transaction({
      type: TransactionType.AppCall,
      sender: senderAccount.addr,
      firstValid: suggestedParams.firstValid,
      lastValid: suggestedParams.lastValid,
      genesisHash: suggestedParams.genesisHash,
      genesisId: suggestedParams.genesisId,
      appCall: appCallFields,
    });

    const createAppTxWithFee = assignFee(createAppTx, {
      feePerByte: suggestedParams.fee,
      minFee: suggestedParams.minFee,
    });

    const signedCreateTx = await senderAccount.signer([createAppTxWithFee], [0]);
    await algod.sendRawTransaction(signedCreateTx);
    const createPendingInfo = await waitForConfirmation(algod, createAppTxWithFee.txId());
    appId = createPendingInfo.appId as bigint;
    printSuccess(`Created application: ID ${appId}`);

    // Small delay to allow indexer to catch up
    printInfo('Waiting for indexer to index transactions...');
    await new Promise(resolve => setTimeout(resolve, 3000));
    printInfo('');
  } catch (error) {
    printError(
      `Failed to create test transactions: ${error instanceof Error ? error.message : String(error)}`,
    );
    printInfo('');
    printInfo('If LocalNet errors occur, try: algokit localnet reset');
    return;
  }

  // =========================================================================
  // Step 3: Search for transactions with default parameters
  // =========================================================================
  printStep(3, 'Searching for transactions with default parameters');

  try {
    // Note: Results are returned oldest to newest (unless address filter is used)
    const txnsResult = await indexer.searchForTransactions({ limit: 10 });

    printSuccess(`Found ${txnsResult.transactions.length} transaction(s)`);
    printInfo('Note: Results are returned oldest to newest (except when using address filter)');
    printInfo('');

    if (txnsResult.transactions.length > 0) {
      printInfo('Recent transactions:');
      for (const tx of txnsResult.transactions.slice(0, 5)) {
        printInfo(`  Transaction ID: ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}`);
        printInfo(`    - txType: ${tx.txType}`);
        printInfo(`    - sender: ${shortenAddress(tx.sender)}`);
        if (tx.confirmedRound !== undefined) {
          printInfo(`    - confirmedRound: ${tx.confirmedRound}`);
        }
        printInfo('');
      }
    }

    printInfo(`Query performed at round: ${txnsResult.currentRound}`);
  } catch (error) {
    printError(
      `searchForTransactions failed: ${error instanceof Error ? error.message : String(error)}`,
    );
  }

  // =========================================================================
  // Step 4: Filter by txType to find specific transaction types
  // =========================================================================
  printStep(4, 'Filtering by txType to find specific transaction types');

  try {
    // Transaction types: pay, keyreg, acfg, axfer, afrz, appl, stpf, hb
    printInfo('Available txType values: pay, keyreg, acfg, axfer, afrz, appl, stpf, hb');
    printInfo('');

    // Search for payment transactions
    printInfo('Searching for payment transactions (txType=pay)...');
    const payTxns = await indexer.searchForTransactions({ txType: 'pay', limit: 5 });
    printSuccess(`Found ${payTxns.transactions.length} payment transaction(s)`);
    if (payTxns.transactions.length > 0) {
      for (const tx of payTxns.transactions.slice(0, 2)) {
        printInfo(
          `  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${formatMicroAlgo(tx.paymentTransaction?.amount ?? 0n)}`,
        );
      }
    }
    printInfo('');

    // Search for asset transfer transactions
    printInfo('Searching for asset transfer transactions (txType=axfer)...');
    const axferTxns = await indexer.searchForTransactions({ txType: 'axfer', limit: 5 });
    printSuccess(`Found ${axferTxns.transactions.length} asset transfer transaction(s)`);
    if (axferTxns.transactions.length > 0) {
      for (const tx of axferTxns.transactions.slice(0, 2)) {
        printInfo(
          `  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: assetId=${tx.assetTransferTransaction?.assetId}`,
        );
      }
    }
    printInfo('');

    // Search for asset config transactions
    printInfo('Searching for asset config transactions (txType=acfg)...');
    const acfgTxns = await indexer.searchForTransactions({ txType: 'acfg', limit: 5 });
    printSuccess(`Found ${acfgTxns.transactions.length} asset config transaction(s)`);
    if (acfgTxns.transactions.length > 0) {
      for (const tx of acfgTxns.transactions.slice(0, 2)) {
        const assetIdDisplay = tx.createdAssetId ?? tx.assetConfigTransaction?.assetId ?? 'N/A';
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: assetId=${assetIdDisplay}`);
      }
    }
    printInfo('');

    // Search for application call transactions
    printInfo('Searching for application call transactions (txType=appl)...');
    const applTxns = await indexer.searchForTransactions({ txType: 'appl', limit: 5 });
    printSuccess(`Found ${applTxns.transactions.length} application call transaction(s)`);
    if (applTxns.transactions.length > 0) {
      for (const tx of applTxns.transactions.slice(0, 2)) {
        const appIdDisplay = tx.createdAppId ?? tx.applicationTransaction?.applicationId ?? 'N/A';
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: appId=${appIdDisplay}`);
      }
    }
  } catch (error) {
    printError(`txType filter failed: ${error instanceof Error ? error.message : String(error)}`);
  }

  // =========================================================================
  // Step 5: Filter by sigType (sig, msig, lsig)
  // =========================================================================
  printStep(5, 'Filtering by sigType (sig, msig, lsig)');

  try {
    // Signature types:
    // - sig: Standard single signature
    // - msig: Multisignature
    // - lsig: Logic signature (smart signature)
    printInfo('Available sigType values: sig, msig, lsig');
    printInfo('');

    // Search for standard signature transactions
    printInfo('Searching for standard signature transactions (sigType=sig)...');
    const sigTxns = await indexer.searchForTransactions({ sigType: 'sig', limit: 5 });
    printSuccess(`Found ${sigTxns.transactions.length} transaction(s) with standard signature`);
    if (sigTxns.transactions.length > 0) {
      for (const tx of sigTxns.transactions.slice(0, 2)) {
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${tx.txType}`);
      }
    }
    printInfo('');

    // Note: msig and lsig transactions may not exist on LocalNet unless specifically created
    printInfo('Searching for multisig transactions (sigType=msig)...');
    const msigTxns = await indexer.searchForTransactions({ sigType: 'msig', limit: 5 });
    printSuccess(`Found ${msigTxns.transactions.length} multisig transaction(s)`);
    printInfo('(Note: Multisig transactions require special setup and may not exist on LocalNet)');
    printInfo('');

    printInfo('Searching for logic signature transactions (sigType=lsig)...');
    const lsigTxns = await indexer.searchForTransactions({ sigType: 'lsig', limit: 5 });
    printSuccess(`Found ${lsigTxns.transactions.length} logic signature transaction(s)`);
    printInfo(
      '(Note: Logic signature transactions require smart signatures and may not exist on LocalNet)',
    );
  } catch (error) {
    printError(`sigType filter failed: ${error instanceof Error ? error.message : String(error)}`);
  }

  // =========================================================================
  // Step 6: Filter by address with addressRole (sender, receiver)
  // =========================================================================
  printStep(6, 'Filtering by address with addressRole (sender, receiver)');

  try {
    // addressRole can be: sender, receiver, freeze-target
    // When using address filter, results are returned newest to oldest
    printInfo('Available addressRole values: sender, receiver, freeze-target');
    printInfo('Note: When using address filter, results are returned newest to oldest');
    printInfo('');

    // Search for transactions where sender is the address
    printInfo(`Searching for transactions where ${shortenAddress(senderAddress)} is sender...`);
    const senderTxns = await indexer.searchForTransactions({
      address: senderAddress,
      addressRole: 'sender',
      limit: 5,
    });
    printSuccess(`Found ${senderTxns.transactions.length} transaction(s) as sender`);
    if (senderTxns.transactions.length > 0) {
      for (const tx of senderTxns.transactions.slice(0, 3)) {
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${tx.txType}`);
      }
    }
    printInfo('');

    // Search for transactions where receiver is the address
    printInfo(`Searching for transactions where ${shortenAddress(receiverAddress)} is receiver...`);
    const receiverTxns = await indexer.searchForTransactions({
      address: receiverAddress,
      addressRole: 'receiver',
      limit: 5,
    });
    printSuccess(`Found ${receiverTxns.transactions.length} transaction(s) as receiver`);
    if (receiverTxns.transactions.length > 0) {
      for (const tx of receiverTxns.transactions.slice(0, 3)) {
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${tx.txType}`);
      }
    }
    printInfo('');

    // Search for transactions involving an address in any role
    printInfo(
      `Searching for all transactions involving ${shortenAddress(senderAddress)} (no role filter)...`,
    );
    const anyRoleTxns = await indexer.searchForTransactions({
      address: senderAddress,
      limit: 5,
    });
    printSuccess(`Found ${anyRoleTxns.transactions.length} transaction(s) involving address`);
    if (anyRoleTxns.transactions.length > 0) {
      for (const tx of anyRoleTxns.transactions.slice(0, 3)) {
        const role = tx.sender === senderAddress ? 'sender' : 'other';
        printInfo(
          `  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${tx.txType} (role: ${role})`,
        );
      }
    }
  } catch (error) {
    printError(
      `address/addressRole filter failed: ${error instanceof Error ? error.message : String(error)}`,
    );
  }

  // =========================================================================
  // Step 7: Filter by round range (minRound, maxRound)
  // =========================================================================
  printStep(7, 'Filtering by round range (minRound, maxRound)');

  try {
    // Get current round
    const latestTxns = await indexer.searchForTransactions({ limit: 1 });
    const currentRound = latestTxns.currentRound;

    printInfo(`Current round: ${currentRound}`);
    printInfo(`Transactions created starting from round: ${startRound}`);
    printInfo('');

    // Filter to recent rounds only
    printInfo(`Searching for transactions from round ${startRound} to ${currentRound}...`);
    const roundFilteredTxns = await indexer.searchForTransactions({
      minRound: startRound,
      maxRound: currentRound,
      limit: 10,
    });

    printSuccess(`Found ${roundFilteredTxns.transactions.length} transaction(s) in round range`);
    if (roundFilteredTxns.transactions.length > 0) {
      const rounds = roundFilteredTxns.transactions
        .map(tx => tx.confirmedRound)
        .filter(r => r !== undefined);
      if (rounds.length > 0) {
        const minFoundRound = rounds.reduce((a, b) => (a! < b! ? a : b));
        const maxFoundRound = rounds.reduce((a, b) => (a! > b! ? a : b));
        printInfo(`  Rounds of found transactions: ${minFoundRound} to ${maxFoundRound}`);
      }
    }
    printInfo('');

    // Single round query
    printInfo(`Searching for transactions in round ${currentRound} only...`);
    const singleRoundTxns = await indexer.searchForTransactions({
      round: currentRound,
      limit: 10,
    });
    printSuccess(
      `Found ${singleRoundTxns.transactions.length} transaction(s) in round ${currentRound}`,
    );
  } catch (error) {
    printError(`round filter failed: ${error instanceof Error ? error.message : String(error)}`);
  }

  // =========================================================================
  // Step 8: Filter by time range (beforeTime, afterTime)
  // =========================================================================
  printStep(8, 'Filtering by time range (beforeTime, afterTime)');

  try {
    // Time filters use RFC 3339 format (ISO 8601, e.g., "2026-01-26T10:00:00.000Z")
    const now = new Date();
    const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000);

    const afterTimeStr = oneHourAgo.toISOString();
    const beforeTimeStr = now.toISOString();

    printInfo('Time filters use RFC 3339 format (ISO 8601)');
    printInfo(`  afterTime: ${afterTimeStr}`);
    printInfo(`  beforeTime: ${beforeTimeStr}`);
    printInfo('');

    printInfo('Searching for transactions in the last hour...');
    const timeFilteredTxns = await indexer.searchForTransactions({
      afterTime: afterTimeStr,
      beforeTime: beforeTimeStr,
      limit: 10,
    });

    printSuccess(`Found ${timeFilteredTxns.transactions.length} transaction(s) in time range`);
    if (timeFilteredTxns.transactions.length > 0) {
      const times = timeFilteredTxns.transactions
        .map(tx => tx.roundTime)
        .filter(t => t !== undefined);
      if (times.length > 0) {
        const minTime = Math.min(...(times as number[]));
        const maxTime = Math.max(...(times as number[]));
        printInfo(`  Time range of found transactions:`);
        printInfo(`    - Earliest: ${new Date(minTime * 1000).toISOString()}`);
        printInfo(`    - Latest: ${new Date(maxTime * 1000).toISOString()}`);
      }
    }
  } catch (error) {
    printError(`time filter failed: ${error instanceof Error ? error.message : String(error)}`);
  }

  // =========================================================================
  // Step 9: Filter by applicationId to find app calls
  // =========================================================================
  printStep(9, 'Filtering by applicationId to find app calls');

  try {
    printInfo(`Searching for transactions involving application ID ${appId}...`);
    const appTxns = await indexer.searchForTransactions({
      applicationId: appId,
      limit: 10,
    });

    printSuccess(`Found ${appTxns.transactions.length} transaction(s) for app ${appId}`);
    if (appTxns.transactions.length > 0) {
      for (const tx of appTxns.transactions) {
        const onComplete = tx.applicationTransaction?.onCompletion;
        const createdApp = tx.createdAppId;
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}:`);
        printInfo(`      txType: ${tx.txType}`);
        if (createdApp) {
          printInfo(`      createdAppId: ${createdApp}`);
        }
        if (onComplete !== undefined) {
          printInfo(`      onCompletion: ${onComplete}`);
        }
      }
    }
    printInfo('');

    // Note: You can combine applicationId with other filters
    printInfo(`Combining applicationId filter with txType=appl...`);
    const combinedAppTxns = await indexer.searchForTransactions({
      applicationId: appId,
      txType: 'appl',
      limit: 10,
    });
    printSuccess(
      `Found ${combinedAppTxns.transactions.length} app call transaction(s) for app ${appId}`,
    );
  } catch (error) {
    printError(
      `applicationId filter failed: ${error instanceof Error ? error.message : String(error)}`,
    );
  }

  // =========================================================================
  // Step 10: Combining multiple filters
  // =========================================================================
  printStep(10, 'Combining multiple filters');

  try {
    printInfo('You can combine multiple filters to narrow down results.');
    printInfo('');

    // Combine txType and address
    printInfo(`Searching for payment transactions from ${shortenAddress(senderAddress)}...`);
    const combinedTxns1 = await indexer.searchForTransactions({
      txType: 'pay',
      address: senderAddress,
      addressRole: 'sender',
      limit: 5,
    });
    printSuccess(`Found ${combinedTxns1.transactions.length} payment transaction(s) from sender`);
    printInfo('');

    // Combine round range and txType
    printInfo(`Searching for asset transfers in recent rounds...`);
    const latestResult = await indexer.searchForTransactions({ limit: 1 });
    const combinedTxns2 = await indexer.searchForTransactions({
      txType: 'axfer',
      minRound: startRound,
      maxRound: latestResult.currentRound,
      limit: 5,
    });
    printSuccess(`Found ${combinedTxns2.transactions.length} asset transfer(s) in recent rounds`);
  } catch (error) {
    printError(
      `combined filters failed: ${error instanceof Error ? error.message : String(error)}`,
    );
  }

  // =========================================================================
  // Step 11: Pagination with limit and next
  // =========================================================================
  printStep(11, 'Demonstrating pagination with limit and next');

  try {
    printInfo('Using limit=2 to demonstrate pagination...');
    const page1 = await indexer.searchForTransactions({ limit: 2 });

    printInfo(`Page 1: Retrieved ${page1.transactions.length} transaction(s)`);
    for (const tx of page1.transactions) {
      printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${tx.txType}`);
    }

    if (page1.nextToken) {
      printInfo(`  - Next token available: ${page1.nextToken.substring(0, 20)}...`);
      printInfo('');

      printInfo('Fetching next page...');
      const page2 = await indexer.searchForTransactions({
        limit: 2,
        next: page1.nextToken,
      });

      printInfo(`Page 2: Retrieved ${page2.transactions.length} transaction(s)`);
      for (const tx of page2.transactions) {
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${tx.txType}`);
      }

      if (page2.nextToken) {
        printInfo(`  - More pages available (nextToken present)`);
      } else {
        printInfo(`  - No more pages (no nextToken)`);
      }
    } else {
      printInfo('  - No pagination needed (all results fit in one page)');
    }
  } catch (error) {
    printError(`pagination failed: ${error instanceof Error ? error.message : String(error)}`);
  }

  // =========================================================================
  // Summary
  // =========================================================================
  printHeader('Summary');
  printInfo('This example demonstrated searchForTransactions() with various filters:');
  printInfo('');
  printInfo('Key filter parameters:');
  printInfo(
    '  - txType: Filter by transaction type (pay, keyreg, acfg, axfer, afrz, appl, stpf, hb)',
  );
  printInfo('  - sigType: Filter by signature type (sig, msig, lsig)');
  printInfo('  - address: Filter by address involvement');
  printInfo('  - addressRole: Specify role (sender, receiver, freeze-target)');
  printInfo('  - minRound/maxRound: Filter by round range');
  printInfo('  - round: Filter by specific round');
  printInfo('  - beforeTime/afterTime: Filter by time (RFC 3339 format)');
  printInfo('  - applicationId: Filter by application ID');
  printInfo('  - assetId: Filter by asset ID');
  printInfo('  - currencyGreaterThan/currencyLessThan: Filter by amount');
  printInfo('  - notePrefix: Filter by note prefix');
  printInfo('  - txId: Find specific transaction by ID');
  printInfo('  - groupId: Filter by group ID');
  printInfo('  - rekeyTo: Filter for rekey transactions');
  printInfo('  - excludeCloseTo: Exclude close-to transactions from results');
  printInfo('');
  printInfo('Result ordering:');
  printInfo('  - Default: Results are returned oldest to newest');
  printInfo('  - With address filter: Results are returned newest to oldest');
  printInfo('');
  printInfo('Pagination:');
  printInfo('  - limit: Maximum number of results per page');
  printInfo('  - next: Token from previous response to get next page');
}

main().catch(error => {
  console.error('Fatal error:', error);
  process.exit(1);
});

---

Other examples in Indexer Client

• Indexer Health Check
• Account Lookup
• Account Assets
• Account Applications
• Account Transactions
• Transaction Lookup
• Transaction Search
• Asset Lookup
• Asset Balances
• Asset Transactions
• Application Lookup
• Application Logs Lookup
• Application Boxes Lookup
• Block Lookup
• Block Headers Search
• Pagination