Skip to content
light theme Algorand Developer Portal dark theme Algorand Developer Portal Algorand Developer Portal

App Call Subscription

← Back to Examples

Description

Section titled “Description”

This example demonstrates application call subscription.

  • Subscribe to app creation with appCreate filter
  • Filter by methodSignature for specific ABI methods
  • Filter by appOnComplete for opt-in calls
  • Use appCallArgumentsMatch for custom argument inspection

Prerequisites

Section titled “Prerequisites”
  • LocalNet running (via algokit localnet start)

Run This Example

Section titled “Run This Example”

From the repository’s examples/subscriber directory:

Terminal window
cd examples/subscriber
npx tsx 05-app-call.ts

Code

Section titled “Code”

View source on GitHub

05-app-call.ts
/**
 * Example: App Call Subscription
 *
 * This example demonstrates application call subscription.
 * - Subscribe to app creation with appCreate filter
 * - Filter by methodSignature for specific ABI methods
 * - Filter by appOnComplete for opt-in calls
 * - Use appCallArgumentsMatch for custom argument inspection
 *
 * Prerequisites:
 * - LocalNet running (via `algokit localnet start`)
 */
import { readFileSync } from 'node:fs'
import { fileURLToPath } from 'node:url'
import { dirname, join } from 'node:path'
import { algo, AlgorandClient, AppFactory } from '@algorandfoundation/algokit-utils'
import { printHeader, printStep, printInfo, printSuccess, printError, shortenAddress, createFilterTester } from './shared/utils.js'


const __filename = fileURLToPath(import.meta.url)
const __dirname = dirname(__filename)


async function main() {
  printHeader('05 — App Call Subscription')


  // Step 1: Connect to LocalNet
  printStep(1, 'Connect to LocalNet')
  const algorand = AlgorandClient.defaultLocalNet()
  const status = await algorand.client.algod.status()
  printInfo(`Current round: ${status.lastRound.toString()}`)
  printSuccess('Connected to LocalNet')


  // Step 2: Create and fund an account
  printStep(2, 'Create and fund account')
  const creator = await algorand.account.fromEnvironment('APP_CREATOR', algo(100))
  const creatorAddr = creator.addr.toString()
  printInfo(`Creator: ${shortenAddress(creatorAddr)}`)
  printSuccess('Account created and funded')


  // Step 3: Deploy TestingApp using AppFactory with embedded ARC-56 spec
  printStep(3, 'Deploy TestingApp via AppFactory')
  const appSpec = JSON.parse(
    readFileSync(join(__dirname, 'shared/artifacts/testing-app.arc56.json'), 'utf-8'),
  )
  const factory = new AppFactory({
    appSpec,
    algorand,
    defaultSender: creator.addr,
  })
  const { result: createResult, appClient } = await factory.send.bare.create({
    sender: creator.addr,
  })
  const appId = createResult.appId
  const createRound = createResult.confirmation.confirmedRound!
  printInfo(`App ID: ${appId.toString()}`)
  printInfo(`Create round: ${createRound.toString()}`)
  printSuccess('TestingApp deployed')


  // Step 4: Make ABI method calls (non-readonly methods produce on-chain transactions)
  printStep(4, 'Make ABI method calls')


  // set_global(uint64,uint64,string,byte[4])void — NoOp
  const setGlobalResult = await appClient.send.call({
    method: 'set_global',
    args: [1n, 2n, 'test', new Uint8Array([0, 1, 2, 3])],
    sender: creator.addr,
  })
  printInfo(`set_global txn: ${setGlobalResult.txIds.at(-1)}`)


  // emitSwapped(uint64,uint64)void — NoOp (emits ARC-28 event)
  const emitResult = await appClient.send.call({
    method: 'emitSwapped',
    args: [42n, 99n],
    sender: creator.addr,
  })
  printInfo(`emitSwapped txn: ${emitResult.txIds.at(-1)}`)


  // opt_in()void — OptIn on-complete
  const optInResult = await appClient.send.optIn({
    method: 'opt_in',
    args: [],
    sender: creator.addr,
  })
  printInfo(`opt_in txn: ${optInResult.txIds.at(-1)}`)
  printSuccess('3 ABI method calls sent')


  // Watermark: just before the app creation round
  const watermarkBefore = createRound - 1n


  const testFilter = createFilterTester(algorand.client.algod, watermarkBefore)


  // Step 5: Subscribe with appCreate: true — matches app creation
  printStep(5, 'Filter: appCreate = true')
  const createTxns = await testFilter(
    'app-create', { appCreate: true }, 1,
    'appCreate filter matched 1 app creation transaction',
    (txn) => {
      const appTxn = txn.applicationTransaction
      printInfo(`  Created app: ${txn.createdAppId} | onComplete: ${appTxn?.onCompletion} | txn: ${txn.id}`)
    },
  )


  // Step 6: Subscribe with appId + methodSignature — matches specific ABI method calls
  printStep(6, 'Filter: appId + methodSignature = set_global')
  const methodTxns = await testFilter(
    'set-global-method', {
      appId: appId,
      methodSignature: 'set_global(uint64,uint64,string,byte[4])void',
    }, 1,
    'methodSignature filter matched 1 set_global call',
    (txn) => {
      const appArgs = txn.applicationTransaction?.applicationArgs
      const selectorHex = appArgs && appArgs.length > 0 ? Buffer.from(appArgs[0].slice(0, 4)).toString('hex') : 'N/A'
      printInfo(
        `  Method call: selector: 0x${selectorHex} | filters: [${txn.filtersMatched?.join(', ')}] | txn: ${txn.id}`,
      )
    },
  )


  // Step 7: Subscribe with appOnComplete filter — matches by on-complete type
  printStep(7, 'Filter: appOnComplete = optin')
  const optInTxns = await testFilter(
    'optin-calls', { appOnComplete: 'optin' }, 1,
    'appOnComplete filter matched 1 opt-in transaction',
    (txn) => {
      const appTxn = txn.applicationTransaction
      printInfo(
        `  OptIn call: app: ${appTxn?.applicationId} | onComplete: ${appTxn?.onCompletion} | filters: [${txn.filtersMatched?.join(', ')}] | txn: ${txn.id}`,
      )
    },
  )


  // Step 8: Demonstrate appCallArgumentsMatch predicate — custom arg inspection
  // Match emitSwapped calls by checking the method selector in the first app arg
  printStep(8, 'Filter: appCallArgumentsMatch predicate')
  const emitSwappedSelector = 'd43cee5d' // method selector for emitSwapped(uint64,uint64)void
  const argMatchTxns = await testFilter(
    'arg-match', {
      appId: appId,
      appCallArgumentsMatch: (args?: readonly Uint8Array[]) => {
        if (!args || args.length === 0) return false
        const selectorHex = Buffer.from(args[0].slice(0, 4)).toString('hex')
        return selectorHex === emitSwappedSelector
      },
    }, 1,
    'appCallArgumentsMatch predicate matched 1 emitSwapped call',
    (txn) => {
      const appArgs = txn.applicationTransaction?.applicationArgs
      if (appArgs && appArgs.length > 0) {
        const selectorHex = Buffer.from(appArgs[0].slice(0, 4)).toString('hex')
        printInfo(
          `  Arg match: selector: 0x${selectorHex} | filters: [${txn.filtersMatched?.join(', ')}] | txn: ${txn.id}`,
        )
      }
    },
  )


  // Step 9: Summary
  printStep(9, 'Summary')
  printInfo(`App ID: ${appId.toString()}`)
  printInfo(`appCreate filter: ${createTxns.length} matched (creation)`)
  printInfo(`methodSignature filter: ${methodTxns.length} matched (set_global)`)
  printInfo(`appOnComplete filter: ${optInTxns.length} matched (opt-in)`)
  printInfo(`appCallArgumentsMatch filter: ${argMatchTxns.length} matched (emitSwapped by selector)`)


  printHeader('Example complete')
}


main().catch((err) => {
  printError(err.message)
  process.exit(1)
})

Other examples

Section titled “Other examples”