Asset Transactions

← Back to Indexer Client

Description

This example demonstrates how to lookup transactions for a specific asset using the IndexerClient lookupAssetTransactions() method.

Prerequisites

• LocalNet running (via algokit localnet start)

Run This Example

From the repository root:

cd examples
npm run example indexer_client/10-asset-transactions.ts

Code

View source on GitHub

10-asset-transactions.ts

/**
 * Example: Asset Transactions
 *
 * This example demonstrates how to lookup transactions for a specific asset using
 * the IndexerClient lookupAssetTransactions() method.
 *
 * Prerequisites:
 * - LocalNet running (via `algokit localnet start`)
 */

import {
  createAlgorandClient,
  createIndexerClient,
  createRandomAccount,
  printError,
  printHeader,
  printInfo,
  printStep,
  printSuccess,
  shortenAddress,
} from '../shared/utils.js'

async function main() {
  printHeader('Asset Transactions Example')

  // Create clients
  const indexer = createIndexerClient()
  const algorand = createAlgorandClient()

  // =========================================================================
  // Step 1: Get a funded account and create additional accounts
  // =========================================================================
  printStep(1, 'Setting up accounts for demonstration')

  let creatorAddress: string
  let holder1Address: string
  let holder2Address: string

  try {
    // Get the dispenser account as the creator
    const dispenser = await algorand.account.dispenserFromEnvironment()
    creatorAddress = dispenser.addr.toString()
    printSuccess(`Creator account (dispenser): ${shortenAddress(creatorAddress)}`)

    // Create additional accounts to hold the asset
    const holder1 = await createRandomAccount(algorand)
    holder1Address = holder1.addr.toString()
    printSuccess(`Holder 1: ${shortenAddress(holder1Address)}`)

    const holder2 = await createRandomAccount(algorand)
    holder2Address = holder2.addr.toString()
    printSuccess(`Holder 2: ${shortenAddress(holder2Address)}`)
  } catch (error) {
    printError(`Failed to set up accounts: ${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 a test asset with freeze address
  // =========================================================================
  printStep(2, 'Creating a test asset with freeze address')

  let assetId: bigint
  let startRound: bigint

  try {
    // Record the starting round for later filtering
    const status = await algorand.client.algod.status()
    startRound = status.lastRound

    // Create asset with freeze address to enable freeze transactions
    printInfo('Creating test asset: TxnToken (TXN)...')
    const result = await algorand.send.assetCreate({
      sender: creatorAddress,
      total: 10_000_000n, // 10,000 units with 3 decimals
      decimals: 3,
      assetName: 'TxnToken',
      unitName: 'TXN',
      url: 'https://example.com/txntoken',
      defaultFrozen: false,
      manager: creatorAddress,
      reserve: creatorAddress,
      freeze: creatorAddress, // Enable freeze functionality
      clawback: creatorAddress,
    })
    assetId = result.assetId
    printSuccess(`Created TxnToken with Asset ID: ${assetId}`)
    printInfo(`  - freeze address: ${shortenAddress(creatorAddress)} (enables freeze transactions)`)
  } catch (error) {
    printError(`Failed to create test asset: ${error instanceof Error ? error.message : String(error)}`)
    printInfo('')
    printInfo('If LocalNet errors occur, try: algokit localnet reset')
    return
  }

  // =========================================================================
  // Step 3: Perform several asset transactions (opt-in, transfer, freeze)
  // =========================================================================
  printStep(3, 'Performing several asset transactions')

  try {
    // 1. Holder 1: Opt-in (axfer to self with 0 amount)
    printInfo('Holder 1 opting into asset...')
    await algorand.send.assetOptIn({
      sender: holder1Address,
      assetId,
    })
    printSuccess('Holder 1 opted in (axfer)')

    // 2. Transfer to Holder 1
    printInfo('Transferring 1000 TXN to Holder 1...')
    await algorand.send.assetTransfer({
      sender: creatorAddress,
      receiver: holder1Address,
      assetId,
      amount: 1_000_000n, // 1000 TXN (with 3 decimals)
    })
    printSuccess('Transfer to Holder 1 complete (axfer)')

    // 3. Holder 2: Opt-in
    printInfo('Holder 2 opting into asset...')
    await algorand.send.assetOptIn({
      sender: holder2Address,
      assetId,
    })
    printSuccess('Holder 2 opted in (axfer)')

    // 4. Transfer to Holder 2
    printInfo('Transferring 500 TXN to Holder 2...')
    await algorand.send.assetTransfer({
      sender: creatorAddress,
      receiver: holder2Address,
      assetId,
      amount: 500_000n, // 500 TXN (with 3 decimals)
    })
    printSuccess('Transfer to Holder 2 complete (axfer)')

    // 5. Freeze Holder 1's account
    printInfo('Freezing Holder 1 account...')
    await algorand.send.assetFreeze({
      sender: creatorAddress,
      assetId,
      freezeTarget: holder1Address,
      frozen: true,
    })
    printSuccess('Holder 1 account frozen (afrz)')

    // 6. Unfreeze Holder 1's account
    printInfo('Unfreezing Holder 1 account...')
    await algorand.send.assetFreeze({
      sender: creatorAddress,
      assetId,
      freezeTarget: holder1Address,
      frozen: false,
    })
    printSuccess('Holder 1 account unfrozen (afrz)')

    // 7. Reconfigure asset (acfg)
    printInfo('Reconfiguring asset (updating manager)...')
    await algorand.send.assetConfig({
      sender: creatorAddress,
      assetId,
      manager: creatorAddress,
      reserve: creatorAddress,
      freeze: creatorAddress,
      clawback: creatorAddress,
    })
    printSuccess('Asset reconfigured (acfg)')

    printInfo('')
    printInfo('Transaction summary:')
    printInfo('  - 1 asset creation (acfg)')
    printInfo('  - 2 opt-ins (axfer with 0 amount)')
    printInfo('  - 2 transfers (axfer with positive amount)')
    printInfo('  - 2 freeze operations (afrz)')
    printInfo('  - 1 asset reconfiguration (acfg)')

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

  // =========================================================================
  // Step 4: Basic lookupAssetTransactions() - Get all transactions for asset
  // =========================================================================
  printStep(4, 'Looking up all transactions for asset with lookupAssetTransactions()')

  try {
    // lookupAssetTransactions() returns all transactions involving an asset
    // Note: Results are returned oldest to newest
    const txnsResult = await indexer.lookupAssetTransactions(assetId)

    printSuccess(`Found ${txnsResult.transactions.length} transaction(s) for Asset ID ${assetId}`)
    printInfo('Note: Results are returned oldest to newest')
    printInfo('')

    if (txnsResult.transactions.length > 0) {
      printInfo('Asset transactions:')
      for (const tx of txnsResult.transactions) {
        printInfo(`  Transaction: ${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}`)
        }

        // Show type-specific details
        if (tx.txType === 'axfer' && tx.assetTransferTransaction) {
          printInfo(`    - receiver: ${shortenAddress(tx.assetTransferTransaction.receiver)}`)
          printInfo(`    - amount: ${tx.assetTransferTransaction.amount.toLocaleString('en-US')}`)
        } else if (tx.txType === 'afrz' && tx.assetFreezeTransaction) {
          printInfo(`    - frozenAddress: ${shortenAddress(tx.assetFreezeTransaction.address)}`)
          printInfo(`    - newFreezeStatus: ${tx.assetFreezeTransaction.newFreezeStatus}`)
        } else if (tx.txType === 'acfg') {
          if (tx.createdAssetId) {
            printInfo(`    - createdAssetId: ${tx.createdAssetId} (asset creation)`)
          } else {
            printInfo(`    - assetId: ${tx.assetConfigTransaction?.assetId} (reconfiguration)`)
          }
        }
        printInfo('')
      }
    }

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

  // =========================================================================
  // Step 5: Filter by address and addressRole - Sender
  // =========================================================================
  printStep(5, 'Filtering by address with addressRole=sender')

  try {
    // addressRole can be: sender, receiver, freeze-target
    printInfo('Available addressRole values: sender, receiver, freeze-target')
    printInfo('')

    printInfo(`Searching for transactions where ${shortenAddress(creatorAddress)} is sender...`)
    const senderTxns = await indexer.lookupAssetTransactions(assetId, {
      address: creatorAddress,
      addressRole: 'sender',
    })

    printSuccess(`Found ${senderTxns.transactions.length} transaction(s) where creator is sender`)
    if (senderTxns.transactions.length > 0) {
      for (const tx of senderTxns.transactions.slice(0, 5)) {
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${tx.txType}`)
      }
    }
  } catch (error) {
    printError(`addressRole=sender filter failed: ${error instanceof Error ? error.message : String(error)}`)
  }

  // =========================================================================
  // Step 6: Filter by address and addressRole - Receiver
  // =========================================================================
  printStep(6, 'Filtering by address with addressRole=receiver')

  try {
    printInfo(`Searching for transactions where ${shortenAddress(holder1Address)} is receiver...`)
    const receiverTxns = await indexer.lookupAssetTransactions(assetId, {
      address: holder1Address,
      addressRole: 'receiver',
    })

    printSuccess(`Found ${receiverTxns.transactions.length} transaction(s) where Holder 1 is receiver`)
    if (receiverTxns.transactions.length > 0) {
      for (const tx of receiverTxns.transactions) {
        if (tx.assetTransferTransaction) {
          printInfo(
            `  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${tx.txType}, amount: ${tx.assetTransferTransaction.amount.toLocaleString('en-US')}`,
          )
        } else {
          printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${tx.txType}`)
        }
      }
    }
  } catch (error) {
    printError(`addressRole=receiver filter failed: ${error instanceof Error ? error.message : String(error)}`)
  }

  // =========================================================================
  // Step 7: Filter by address and addressRole - Freeze-target
  // =========================================================================
  printStep(7, 'Filtering by address with addressRole=freeze-target')

  try {
    // freeze-target filters for accounts that were the target of freeze operations
    printInfo(`Searching for freeze transactions targeting ${shortenAddress(holder1Address)}...`)
    const freezeTargetTxns = await indexer.lookupAssetTransactions(assetId, {
      address: holder1Address,
      addressRole: 'freeze-target',
    })

    printSuccess(`Found ${freezeTargetTxns.transactions.length} freeze transaction(s) targeting Holder 1`)
    if (freezeTargetTxns.transactions.length > 0) {
      for (const tx of freezeTargetTxns.transactions) {
        if (tx.assetFreezeTransaction) {
          printInfo(
            `  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: ${tx.txType}, newFreezeStatus: ${tx.assetFreezeTransaction.newFreezeStatus}`,
          )
        }
      }
    }
    printInfo('')
    printInfo('Note: freeze-target is specifically for afrz transactions targeting an account')
  } catch (error) {
    printError(`addressRole=freeze-target filter failed: ${error instanceof Error ? error.message : String(error)}`)
  }

  // =========================================================================
  // Step 8: Filter by txType - Asset Transfer (axfer)
  // =========================================================================
  printStep(8, 'Filtering by txType for specific asset operations')

  try {
    // txType values relevant to assets: acfg (config), axfer (transfer), afrz (freeze)
    printInfo('Asset-related txType values: acfg (config), axfer (transfer), afrz (freeze)')
    printInfo('')

    // Search for asset transfers only
    printInfo('Searching for asset transfer transactions (txType=axfer)...')
    const axferTxns = await indexer.lookupAssetTransactions(assetId, {
      txType: 'axfer',
    })
    printSuccess(`Found ${axferTxns.transactions.length} asset transfer transaction(s)`)
    if (axferTxns.transactions.length > 0) {
      for (const tx of axferTxns.transactions.slice(0, 4)) {
        const amount = tx.assetTransferTransaction?.amount ?? 0n
        const amountStr = amount === 0n ? '0 (opt-in)' : amount.toLocaleString('en-US')
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: amount=${amountStr}`)
      }
    }
    printInfo('')

    // Search for asset freeze transactions
    printInfo('Searching for asset freeze transactions (txType=afrz)...')
    const afrzTxns = await indexer.lookupAssetTransactions(assetId, {
      txType: 'afrz',
    })
    printSuccess(`Found ${afrzTxns.transactions.length} asset freeze transaction(s)`)
    if (afrzTxns.transactions.length > 0) {
      for (const tx of afrzTxns.transactions) {
        const frozen = tx.assetFreezeTransaction?.newFreezeStatus ?? false
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: frozen=${frozen}`)
      }
    }
    printInfo('')

    // Search for asset config transactions
    printInfo('Searching for asset config transactions (txType=acfg)...')
    const acfgTxns = await indexer.lookupAssetTransactions(assetId, {
      txType: 'acfg',
    })
    printSuccess(`Found ${acfgTxns.transactions.length} asset config transaction(s)`)
    if (acfgTxns.transactions.length > 0) {
      for (const tx of acfgTxns.transactions) {
        if (tx.createdAssetId) {
          printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: asset creation`)
        } else {
          printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: asset reconfiguration`)
        }
      }
    }
  } catch (error) {
    printError(`txType filter failed: ${error instanceof Error ? error.message : String(error)}`)
  }

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

  try {
    // Get current round
    const latestTxns = await indexer.lookupAssetTransactions(assetId, { limit: 1 })
    const currentRound = latestTxns.currentRound

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

    // Filter by round range
    printInfo(`Searching for transactions from round ${startRound} to ${currentRound}...`)
    const roundFilteredTxns = await indexer.lookupAssetTransactions(assetId, {
      minRound: startRound,
      maxRound: currentRound,
    })

    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}`)
      }
    }
  } catch (error) {
    printError(`round filter failed: ${error instanceof Error ? error.message : String(error)}`)
  }

  // =========================================================================
  // Step 10: Filter by time range (beforeTime, afterTime)
  // =========================================================================
  printStep(10, '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.lookupAssetTransactions(assetId, {
      afterTime: afterTimeStr,
      beforeTime: beforeTimeStr,
    })

    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 11: Filter by currency amount
  // =========================================================================
  printStep(11, 'Filtering by currency amount (currencyGreaterThan, currencyLessThan)')

  try {
    // currencyGreaterThan/currencyLessThan filter by transaction amount
    printInfo('Searching for transfers with amount > 0 (excludes opt-ins)...')
    const nonZeroTxns = await indexer.lookupAssetTransactions(assetId, {
      txType: 'axfer',
      currencyGreaterThan: 0n,
    })

    printSuccess(`Found ${nonZeroTxns.transactions.length} transfer(s) with amount > 0`)
    if (nonZeroTxns.transactions.length > 0) {
      for (const tx of nonZeroTxns.transactions) {
        const amount = tx.assetTransferTransaction?.amount ?? 0n
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: amount=${amount.toLocaleString('en-US')}`)
      }
    }
    printInfo('')

    // Filter for large transfers only
    printInfo('Searching for transfers with amount > 500,000 (> 500 TXN)...')
    const largeTxns = await indexer.lookupAssetTransactions(assetId, {
      txType: 'axfer',
      currencyGreaterThan: 500_000n,
    })

    printSuccess(`Found ${largeTxns.transactions.length} large transfer(s)`)
    if (largeTxns.transactions.length > 0) {
      for (const tx of largeTxns.transactions) {
        const amount = tx.assetTransferTransaction?.amount ?? 0n
        printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: amount=${amount.toLocaleString('en-US')}`)
      }
    }
  } catch (error) {
    printError(`currency filter failed: ${error instanceof Error ? error.message : String(error)}`)
  }

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

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

    // Combine txType and address
    printInfo(`Searching for asset transfers TO ${shortenAddress(holder1Address)}...`)
    const combinedTxns1 = await indexer.lookupAssetTransactions(assetId, {
      txType: 'axfer',
      address: holder1Address,
      addressRole: 'receiver',
    })
    printSuccess(`Found ${combinedTxns1.transactions.length} transfer(s) to Holder 1`)
    for (const tx of combinedTxns1.transactions) {
      const amount = tx.assetTransferTransaction?.amount ?? 0n
      printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: amount=${amount.toLocaleString('en-US')}`)
    }
    printInfo('')

    // Combine round range and txType
    printInfo('Searching for freeze transactions in recent rounds...')
    const latestResult = await indexer.lookupAssetTransactions(assetId, { limit: 1 })
    const combinedTxns2 = await indexer.lookupAssetTransactions(assetId, {
      txType: 'afrz',
      minRound: startRound,
      maxRound: latestResult.currentRound,
    })
    printSuccess(`Found ${combinedTxns2.transactions.length} freeze transaction(s) in recent rounds`)
    for (const tx of combinedTxns2.transactions) {
      const frozen = tx.assetFreezeTransaction?.newFreezeStatus ?? false
      printInfo(`  - ${tx.id ? shortenAddress(tx.id, 8, 6) : 'N/A'}: frozen=${frozen}, round=${tx.confirmedRound}`)
    }
  } catch (error) {
    printError(`combined filters failed: ${error instanceof Error ? error.message : String(error)}`)
  }

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

  try {
    printInfo('Using limit=3 to demonstrate pagination...')
    const page1 = await indexer.lookupAssetTransactions(assetId, { limit: 3 })

    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.lookupAssetTransactions(assetId, {
        limit: 3,
        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 lookupAssetTransactions() with various filters:')
  printInfo('')
  printInfo('Key characteristics:')
  printInfo('  - Results are returned oldest to newest')
  printInfo('  - Returns all transaction types involving the asset (acfg, axfer, afrz)')
  printInfo('')
  printInfo('Transaction types for assets:')
  printInfo('  - acfg: Asset configuration (create, reconfigure, destroy)')
  printInfo('  - axfer: Asset transfer (opt-in with 0 amount, transfers, close-out)')
  printInfo('  - afrz: Asset freeze (freeze/unfreeze account holdings)')
  printInfo('')
  printInfo('Address filtering with addressRole:')
  printInfo('  - sender: Transactions where address is the sender')
  printInfo('  - receiver: Transactions where address is the receiver')
  printInfo('  - freeze-target: Freeze transactions targeting the address')
  printInfo('')
  printInfo('Other filter parameters:')
  printInfo('  - txType: Filter by transaction type (acfg, axfer, afrz)')
  printInfo('  - minRound/maxRound: Filter by round range')
  printInfo('  - beforeTime/afterTime: Filter by time (RFC 3339 format)')
  printInfo('  - currencyGreaterThan/currencyLessThan: Filter by amount')
  printInfo('  - sigType: Filter by signature type (sig, msig, lsig)')
  printInfo('  - notePrefix: Filter by note prefix')
  printInfo('  - txId: Find specific transaction by ID')
  printInfo('  - excludeCloseTo: Exclude close-to transactions')
  printInfo('  - rekeyTo: Filter for rekey transactions')
  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