@chainlink/ccip-cli 0.0.0 → 0.90.0

package/src/commands/send.ts

@@ -0,0 +1,316 @@
+import {
+  type AnyMessage,
+  type CCIPVersion,
+  type ChainStatic,
+  type EVMChain,
+  type ExtraArgs,
+  ChainFamily,
+  bigIntReplacer,
+  estimateExecGasForRequest,
+  fetchCCIPRequestsInTx,
+  getDataBytes,
+  networkInfo,
+  sourceToDestTokenAmounts,
+} from '@chainlink/ccip-sdk/src/index.ts'
+import { type BytesLike, dataLength, formatUnits, toUtf8Bytes } from 'ethers'
+import type { Argv } from 'yargs'
+
+import type { GlobalOpts } from '../index.ts'
+import { Format } from './types.ts'
+import { logParsedError, parseTokenAmounts, prettyRequest, withDateTimestamp } from './utils.ts'
+import { fetchChainsFromRpcs } from '../providers/index.ts'
+
+export const command = 'send <source> <router> <dest>'
+export const describe = 'Send a CCIP message from router on source to dest'
+
+export const builder = (yargs: Argv) =>
+  yargs
+    .positional('source', {
+      type: 'string',
+      demandOption: true,
+      describe: 'source network, chainId or name',
+      example: 'ethereum-testnet-sepolia',
+    })
+    .positional('router', {
+      type: 'string',
+      demandOption: true,
+      describe: 'router contract address on source',
+    })
+    .positional('dest', {
+      type: 'string',
+      demandOption: true,
+      describe: 'destination network, chainId or name',
+      example: 'ethereum-testnet-sepolia-arbitrum-1',
+    })
+    .options({
+      receiver: {
+        alias: 'R',
+        type: 'string',
+        describe:
+          'Receiver of the message; defaults to the sender wallet address if same network family',
+      },
+      data: {
+        alias: 'd',
+        type: 'string',
+        describe: 'Data to send in the message (non-hex will be utf-8 encoded)',
+        example: '0x1234',
+      },
+      'gas-limit': {
+        alias: ['L', 'compute-units'],
+        type: 'number',
+        describe:
+          'Gas limit for receiver callback execution; defaults to default configured on ramps',
+        default: 0,
+      },
+      'estimate-gas-limit': {
+        type: 'number',
+        describe:
+          'Estimate gas limit for receiver callback execution; argument is a % margin to add to the estimate',
+        example: '10',
+        conflicts: 'gas-limit',
+      },
+      'allow-out-of-order-exec': {
+        alias: 'ooo',
+        type: 'boolean',
+        describe:
+          'Allow execution of messages out of order (i.e. sender nonce not enforced, only v1.5+ lanes, mandatory for some dests)',
+      },
+      'fee-token': {
+        type: 'string',
+        describe:
+          'Address or symbol of the fee token (e.g. LINK address on source); if not provided, will pay in native',
+      },
+      'transfer-tokens': {
+        alias: 't',
+        type: 'array',
+        string: true,
+        describe: 'List of token amounts (on source) to transfer to the receiver',
+        example: '0xtoken=0.1',
+      },
+      wallet: {
+        alias: 'w',
+        type: 'string',
+        describe:
+          'Wallet to send transactions with; pass `ledger[:index_or_derivation]` to use Ledger USB hardware wallet, or private key in `USER_KEY` environment variable',
+      },
+      'token-receiver': {
+        type: 'string',
+        describe: "Address of the Solana tokenReceiver (if different than program's receiver)",
+      },
+      account: {
+        type: 'array',
+        string: true,
+        describe:
+          'List of accounts needed by Solana receiver program; append `=rw` to specify account as writable; can be specified multiple times',
+        example: 'requiredPdaAddress=rw',
+      },
+      'only-get-fee': {
+        type: 'boolean',
+        describe: 'Fetch and print the fee for the transaction, then exit',
+      },
+      'only-estimate': {
+        type: 'boolean',
+        describe: 'Only estimate dest exec gasLimit',
+      },
+      'approve-max': {
+        type: 'boolean',
+        describe:
+          "Approve the maximum amount of tokens to transfer; default=false approves only what's needed",
+      },
+    })
+    .check(
+      ({ 'transfer-tokens': transferTokens }) =>
+        !transferTokens || transferTokens.every((t) => /^[^=]+=\d+(\.\d+)?$/.test(t)),
+    )
+
+export async function handler(argv: Awaited<ReturnType<typeof builder>['argv']> & GlobalOpts) {
+  let destroy
+  const destroy$ = new Promise((resolve) => {
+    destroy = resolve
+  })
+  return sendMessage(argv, destroy$)
+    .catch((err) => {
+      process.exitCode = 1
+      if (!logParsedError(err)) console.error(err)
+    })
+    .finally(destroy)
+}
+
+async function sendMessage(
+  argv: Awaited<ReturnType<typeof builder>['argv']> & GlobalOpts,
+  destroy: Promise<unknown>,
+) {
+  const sourceNetwork = networkInfo(argv.source)
+  const destNetwork = networkInfo(argv.dest)
+  const getChain = fetchChainsFromRpcs(argv, undefined, destroy)
+  const source = await getChain(sourceNetwork.name)
+
+  let data: BytesLike
+  if (argv.data) {
+    try {
+      data = getDataBytes(argv.data)
+    } catch (_) {
+      data = toUtf8Bytes(argv.data)
+    }
+  } else {
+    data = '0x'
+  }
+
+  const tokenAmounts: { token: string; amount: bigint }[] = argv.transferTokens?.length
+    ? await parseTokenAmounts(source, argv.transferTokens)
+    : []
+
+  let receiver = argv.receiver
+  let tokenReceiver
+  let accounts,
+    accountIsWritableBitmap = 0n
+  if (destNetwork.family === ChainFamily.Solana) {
+    if (argv.tokenReceiver) tokenReceiver = argv.tokenReceiver
+    else if (!tokenAmounts.length) {
+      tokenReceiver = '11111111111111111111111111111111'
+    } else if (!dataLength(data)) {
+      // sending tokens without data, i.e. not for a receiver contract
+      tokenReceiver = receiver
+      receiver = '11111111111111111111111111111111'
+    } else {
+      throw new Error('--token-receiver is required when sending tokens with data')
+    }
+
+    if (argv.account) {
+      accounts = argv.account.map((account, i) => {
+        if (account.endsWith('=rw')) {
+          accountIsWritableBitmap |= 1n << BigInt(i)
+          account = account.substring(0, account.length - 3)
+        }
+        return account
+      })
+    } else accounts = [] as string[]
+  } else if (argv.tokenReceiver || argv.account?.length) {
+    throw new Error('--token-receiver and --account intended only for Solana dest')
+  }
+
+  if (!receiver) {
+    if (sourceNetwork.family !== destNetwork.family)
+      throw new Error('--receiver is required when sending to a different chain family')
+    receiver = await source.getWalletAddress(argv) // send to self if same family
+  }
+
+  if (argv.estimateGasLimit != null || argv.onlyEstimate) {
+    // TODO: implement for all chain families
+    if (destNetwork.family !== ChainFamily.EVM)
+      throw new Error(`Estimating gasLimit supported only on EVM, got=${destNetwork.family}`)
+    const dest = (await getChain(destNetwork.chainSelector)) as unknown as EVMChain
+    const onRamp = await source.getOnRampForRouter(argv.router, destNetwork.chainSelector)
+    const lane = {
+      sourceChainSelector: source.network.chainSelector,
+      destChainSelector: destNetwork.chainSelector,
+      onRamp,
+      version: (await source.typeAndVersion(onRamp))[1] as CCIPVersion,
+    }
+    const destTokenAmounts = await sourceToDestTokenAmounts(
+      source,
+      destNetwork.chainSelector,
+      onRamp,
+      tokenAmounts,
+    )
+
+    const estimated = await estimateExecGasForRequest(source, dest, {
+      lane,
+      message: {
+        sender: await source.getWalletAddress(argv),
+        receiver,
+        data,
+        tokenAmounts: destTokenAmounts,
+      },
+    })
+    console.log('Estimated gasLimit:', estimated)
+    argv.gasLimit = Math.ceil(estimated * (1 + (argv.estimateGasLimit ?? 0) / 100))
+    if (argv.onlyEstimate) return
+  }
+
+  // `--allow-out-of-order-exec` forces EVMExtraArgsV2, which shouldn't work on v1.2 lanes;
+  // otherwise, fallsback to EVMExtraArgsV1 (compatible with v1.2 & v1.5)
+  const extraArgs = {
+    ...(argv.allowOutOfOrderExec != null || destNetwork.family !== ChainFamily.EVM
+      ? { allowOutOfOrderExecution: !!argv.allowOutOfOrderExec }
+      : {}),
+    ...(destNetwork.family === ChainFamily.Solana
+      ? { computeUnits: BigInt(argv.gasLimit) }
+      : { gasLimit: BigInt(argv.gasLimit) }),
+    ...(tokenReceiver ? { tokenReceiver } : {}),
+    ...(accounts ? { accounts, accountIsWritableBitmap } : {}),
+  }
+
+  let feeToken, feeTokenInfo
+  if (argv.feeToken) {
+    try {
+      feeToken = (source.constructor as ChainStatic).getAddress(argv.feeToken)
+      feeTokenInfo = await source.getTokenInfo(feeToken)
+    } catch (_) {
+      const feeTokens = await source.listFeeTokens(argv.router)
+      console.debug('supported feeTokens:', feeTokens)
+      for (const [token, info] of Object.entries(feeTokens)) {
+        if (info.symbol === 'UNKNOWN' || info.symbol !== argv.feeToken) continue
+        feeToken = token
+        feeTokenInfo = info
+        break
+      }
+      if (!feeTokenInfo) throw new Error(`Fee token "${argv.feeToken}" not found`)
+    }
+  } else {
+    const nativeToken = await source.getNativeTokenForRouter(argv.router)
+    feeTokenInfo = await source.getTokenInfo(nativeToken)
+  }
+
+  const message: AnyMessage = {
+    receiver,
+    data,
+    extraArgs: extraArgs as ExtraArgs,
+    feeToken, // feeToken==ZeroAddress means native
+    tokenAmounts,
+  }
+
+  // calculate fee
+  const fee = await source.getFee(argv.router, destNetwork.chainSelector, message)
+
+  console.info(
+    'Fee:',
+    fee,
+    '=',
+    formatUnits(fee, feeTokenInfo.decimals),
+    !argv.feeToken && feeTokenInfo.symbol.startsWith('W')
+      ? feeTokenInfo.symbol.substring(1)
+      : feeTokenInfo.symbol,
+  )
+  if (argv.onlyGetFee) return
+
+  const tx = await source.sendMessage(
+    argv.router,
+    destNetwork.chainSelector,
+    { ...message, fee },
+    argv,
+  )
+  console.log(
+    '🚀 Sending message to',
+    tokenReceiver || receiver,
+    '@',
+    destNetwork.name,
+    ', tx =>',
+    tx.hash,
+  )
+
+  // print CCIPRequest from tx receipt
+  const request = (await fetchCCIPRequestsInTx(tx))[0]
+
+  switch (argv.format) {
+    case Format.log:
+      console.log(`message ${request.log.index} =`, withDateTimestamp(request))
+      break
+    case Format.pretty:
+      await prettyRequest(source, request)
+      break
+    case Format.json:
+      console.info(JSON.stringify(request, bigIntReplacer, 2))
+      break
+  }
+}

package/src/commands/show.ts

@@ -0,0 +1,151 @@
+import util from 'util'
+
+import {
+  type CCIPRequest,
+  ChainFamily,
+  bigIntReplacer,
+  discoverOffRamp,
+  fetchCCIPMessageById,
+  fetchCCIPRequestsInTx,
+  networkInfo,
+} from '@chainlink/ccip-sdk/src/index.ts'
+import type { Argv } from 'yargs'
+
+import type { GlobalOpts } from '../index.ts'
+import { Format } from './types.ts'
+import {
+  logParsedError,
+  prettyCommit,
+  prettyReceipt,
+  prettyRequest,
+  selectRequest,
+  withDateTimestamp,
+} from './utils.ts'
+import { fetchChainsFromRpcs } from '../providers/index.ts'
+
+export const command = ['show <tx-hash>', '* <tx-hash>']
+export const describe = 'Show details of a CCIP request'
+
+export const builder = (yargs: Argv) =>
+  yargs
+    .positional('tx-hash', {
+      type: 'string',
+      demandOption: true,
+      describe: 'transaction hash of the request (source) message',
+    })
+    .options({
+      'log-index': {
+        type: 'number',
+        describe:
+          'Pre-select a message request by logIndex, if more than one in tx; by default, a selection menu is shown',
+      },
+      'id-from-source': {
+        type: 'string',
+        describe: 'Search by messageId instead of txHash; requires specifying source network',
+      },
+    })
+
+export async function handler(argv: Awaited<ReturnType<typeof builder>['argv']> & GlobalOpts) {
+  let destroy
+  const destroy$ = new Promise((resolve) => {
+    destroy = resolve
+  })
+  return showRequests(argv, destroy$)
+    .catch((err) => {
+      process.exitCode = 1
+      if (!logParsedError(err)) console.error(err)
+    })
+    .finally(destroy)
+}
+
+async function showRequests(argv: Parameters<typeof handler>[0], destroy: Promise<unknown>) {
+  let source, getChain, tx, request: CCIPRequest
+  // messageId not yet implemented for Solana
+  if (argv.idFromSource) {
+    getChain = fetchChainsFromRpcs(argv, undefined, destroy)
+    const sourceNetwork = networkInfo(argv.idFromSource)
+    if (sourceNetwork.family === ChainFamily.Solana) {
+      throw new Error(
+        `Message ID search is not yet supported for Solana networks.\n` +
+          `Please use show with Solana transaction signature instead`,
+      )
+    }
+    source = await getChain(sourceNetwork.chainId)
+    request = await fetchCCIPMessageById(source, argv.txHash, argv)
+  } else {
+    const [getChain_, tx$] = fetchChainsFromRpcs(argv, argv.txHash, destroy)
+    getChain = getChain_
+    tx = await tx$
+    source = tx.chain
+    request = await selectRequest(await fetchCCIPRequestsInTx(tx), 'to know more', argv)
+  }
+
+  const offchainTokenData = await source.fetchOffchainTokenData(request)
+
+  switch (argv.format) {
+    case Format.log: {
+      console.log(
+        `message ${request.log.index} =`,
+        withDateTimestamp(request),
+        '\nattestations =',
+        offchainTokenData,
+      )
+      break
+    }
+    case Format.pretty:
+      await prettyRequest(source, request, offchainTokenData)
+      break
+    case Format.json:
+      console.info(JSON.stringify({ ...request, offchainTokenData }, bigIntReplacer, 2))
+      break
+  }
+  if (request.tx.error) throw new Error(`Request tx reverted: ${util.inspect(request.tx.error)}`)
+
+  const dest = await getChain(request.lane.destChainSelector)
+  const offRamp = await discoverOffRamp(source, dest, request.lane.onRamp)
+  const commitStore = await dest.getCommitStoreForOffRamp(offRamp)
+
+  const commit = await dest.fetchCommitReport(commitStore, request, argv)
+  switch (argv.format) {
+    case Format.log:
+      console.log('commit =', commit)
+      break
+    case Format.pretty:
+      await prettyCommit(dest, commit, request)
+      break
+    case Format.json:
+      console.info(JSON.stringify(commit, bigIntReplacer, 2))
+      break
+  }
+
+  let found = false
+  for await (const receipt of dest.fetchExecutionReceipts(
+    offRamp,
+    new Set([request.message.header.messageId]),
+    {
+      startBlock: commit.log.blockNumber,
+      page: argv.page,
+      commit: commit.report,
+    },
+  )) {
+    switch (argv.format) {
+      case Format.log:
+        console.log('receipt =', withDateTimestamp(receipt))
+        break
+      case Format.pretty:
+        if (!found) console.info('Receipts (dest):')
+        prettyReceipt(
+          receipt,
+          request,
+          receipt.log.tx?.from ??
+            (await dest.getTransaction(receipt.log.transactionHash).catch(() => null))?.from,
+        )
+        break
+      case Format.json:
+        console.info(JSON.stringify(receipt, bigIntReplacer, 2))
+        break
+    }
+    found = true
+  }
+  if (!found) console.warn(`No execution receipt found for request`)
+}

package/src/commands/supported-tokens.ts

@@ -0,0 +1,245 @@
+/**
+ * CCIP Token Discovery Service
+ *
+ * Discovers and validates tokens that can be transferred between chains using Chainlink's CCIP.
+ * The service handles pagination, parallel processing, and comprehensive error collection.
+ *
+ * Architecture:
+ * 1. Chain & Contract Setup: Validates cross-chain paths and initializes core contracts
+ * 2. Token Discovery: Fetches all registered tokens with pagination
+ * 3. Support Validation: Checks token support for destination chain
+ * 4. Detail Collection: Gathers token and pool information in parallel
+ *
+ * Performance Considerations:
+ * - Uses batching to prevent RPC timeouts (configurable batch sizes)
+ * - Implements parallel processing with rate limiting
+ * - Memory-efficient token processing through pagination
+ *
+ * Error Handling:
+ * - Individual token failures don't halt the process
+ * - Errors are collected and reported comprehensively
+ * - Detailed error reporting for debugging
+ *
+ * @module supported-tokens
+ */
+
+import {
+  type Chain,
+  type RateLimiterState,
+  bigIntReplacer,
+  networkInfo,
+} from '@chainlink/ccip-sdk/src/index.ts'
+import { search } from '@inquirer/prompts'
+import { formatUnits } from 'ethers'
+import type { Argv } from 'yargs'
+
+import { Format } from './types.ts'
+import { formatDuration, logParsedError, prettyTable } from './utils.ts'
+import type { GlobalOpts } from '../index.ts'
+import { fetchChainsFromRpcs } from '../providers/index.ts'
+
+export const command = ['getSupportedTokens <source> <address> [token]']
+export const describe =
+  'List supported tokens in a given Router/OnRamp/TokenAdminRegistry, and/or show info about token/pool'
+
+export const builder = (yargs: Argv) =>
+  yargs
+    .positional('source', {
+      type: 'string',
+      demandOption: true,
+      describe: 'source network, chainId or name',
+      example: 'ethereum-testnet-sepolia',
+    })
+    .positional('address', {
+      type: 'string',
+      demandOption: true,
+      describe: 'router/onramp/tokenAdminRegistry/tokenPool contract address on source',
+    })
+    .positional('token', {
+      type: 'string',
+      demandOption: false,
+      describe:
+        'If address is router/onramp/tokenAdminRegistry, token may be used to pre-select a token from the supported list',
+    })
+
+export async function handler(argv: Awaited<ReturnType<typeof builder>['argv']> & GlobalOpts) {
+  let destroy
+  const destroy$ = new Promise((resolve) => {
+    destroy = resolve
+  })
+  return getSupportedTokens(argv, destroy$)
+    .catch((err) => {
+      process.exitCode = 1
+      if (!logParsedError(err)) console.error(err)
+    })
+    .finally(destroy)
+}
+
+async function getSupportedTokens(argv: Parameters<typeof handler>[0], destroy: Promise<unknown>) {
+  const sourceNetwork = networkInfo(argv.source)
+  const getChain = fetchChainsFromRpcs(argv, undefined, destroy)
+  const source = await getChain(sourceNetwork.name)
+  let registry
+  try {
+    registry = await source.getTokenAdminRegistryFor(argv.address)
+  } catch (_) {
+    // ignore
+  }
+
+  let info, tokenPool, poolConfigs, registryConfig
+  if (registry && !argv.token) {
+    const feeTokens = await source.listFeeTokens(argv.address)
+    switch (argv.format) {
+      case Format.pretty:
+        console.info('Fee Tokens:')
+        console.table(feeTokens)
+        break
+      case Format.json:
+        console.log(JSON.stringify(feeTokens, null, 2))
+        break
+      default:
+        console.log('feeTokens:', feeTokens)
+    }
+
+    // router + interactive list
+    info = await listTokens(source, registry, argv)
+    if (!info) return // format != pretty
+    registryConfig = await source.getRegistryTokenConfig(registry, info.token)
+    tokenPool = registryConfig.tokenPool
+    if (!tokenPool)
+      throw new Error(`TokenPool not set in tokenAdminRegistry=${registry} for token=${info.token}`)
+    poolConfigs = await source.getTokenPoolConfigs(tokenPool)
+  } else {
+    if (!argv.token) {
+      // tokenPool
+      tokenPool = argv.address
+      poolConfigs = await source.getTokenPoolConfigs(tokenPool)
+      registry ??= await source.getTokenAdminRegistryFor(poolConfigs.router)
+      ;[info, registryConfig] = await Promise.all([
+        source.getTokenInfo(poolConfigs.token),
+        source.getRegistryTokenConfig(registry, poolConfigs.token),
+      ])
+    } else {
+      registry ??= await source.getTokenAdminRegistryFor(argv.address)
+      // router|ramp|registry + token
+      info = await source.getTokenInfo(argv.token)
+
+      registryConfig = await source.getRegistryTokenConfig(registry, argv.token)
+      tokenPool = registryConfig.tokenPool
+      if (!tokenPool)
+        throw new Error(
+          `TokenPool not set in tokenAdminRegistry=${registry} for token=${argv.token}`,
+        )
+      poolConfigs = await source.getTokenPoolConfigs(tokenPool)
+    }
+
+    if (argv.format === Format.json) {
+      console.log(JSON.stringify({ ...info, tokenPool, ...poolConfigs }, bigIntReplacer, 2))
+      return
+    } else if (argv.format === Format.log) {
+      console.log('Token:', poolConfigs.token, info)
+      console.log('Token Pool:', tokenPool)
+      console.log('Pool Configs:', poolConfigs)
+      return
+    }
+  }
+  const remotes = await source.getTokenPoolRemotes(tokenPool)
+
+  prettyTable({
+    network: `${source.network.name} [${source.network.chainSelector}]`,
+    token: poolConfigs.token,
+    symbol: info.symbol,
+    name: info.name,
+    decimals: info.decimals,
+    tokenPool,
+    typeAndVersion: poolConfigs.typeAndVersion,
+    router: poolConfigs.router,
+    tokenAdminRegistry: registry,
+    administrator: registryConfig.administrator,
+    ...(registryConfig.pendingAdministrator && {
+      pendingAdministrator: registryConfig.pendingAdministrator,
+    }),
+  })
+  const remotesLen = Object.keys(remotes).length
+  if (remotesLen > 0) console.info('Remotes [', remotesLen, ']:')
+  for (const [network, remote] of Object.entries(remotes))
+    prettyTable({
+      remoteNetwork: `${network} [${networkInfo(network).chainSelector}]`,
+      remoteToken: remote.remoteToken,
+      remotePool: remote.remotePools,
+      inbound: prettyRateLimiter(remote.inboundRateLimiterState, info),
+      outbound: prettyRateLimiter(remote.outboundRateLimiterState, info),
+    })
+}
+
+async function listTokens(source: Chain, registry: string, argv: GlobalOpts) {
+  const tokens = await source.getSupportedTokens(registry)
+  const infos: { token: string; symbol: string; decimals: number; name?: string }[] = []
+  const batch = 500
+  for (let i = 0; i < tokens.length; i += batch) {
+    const infos_ = (
+      await Promise.all(
+        tokens.slice(i, i + batch).map((token) =>
+          source.getTokenInfo(token).then(
+            (info) => {
+              const res = { token, ...info }
+              if (argv.format === Format.log) {
+                // Format.log prints out-of-order, as it fetches data, concurrently
+                console.info(token, '=', info)
+              }
+              return res
+            },
+            (err) => {
+              console.debug(`getTokenInfo errored`, token, err)
+            },
+          ),
+        ),
+      )
+    ).filter((e) => e !== undefined)
+    if (argv.format === Format.json) {
+      // Format.json keeps order, prints newline-separated objects
+      for (const info of infos_) {
+        console.log(JSON.stringify(info))
+      }
+    }
+    infos.push(...infos_)
+  }
+  if (argv.format !== Format.pretty) return // Format.pretty interactive search and details
+
+  return search({
+    message: 'Select a token to know more:',
+    pageSize: 20,
+    source: (term) => {
+      const filtered = infos.filter(
+        (info) =>
+          !term ||
+          `${info.token} ${info.symbol} ${info.name ?? ''} ${info.decimals}`
+            .toLowerCase()
+            .includes(term.toLowerCase()),
+      )
+      const symbolPad = Math.min(Math.max(...filtered.map(({ symbol }) => symbol.length)), 10)
+      const decimalsPad = Math.max(...filtered.map(({ decimals }) => decimals.toString().length))
+      return filtered.map((info, i) => ({
+        name: `${info.token}\t[${info.decimals.toString().padStart(decimalsPad)}] ${info.symbol.padEnd(symbolPad)}\t${info.name ?? ''}`,
+        value: info,
+        short: `${info.token} [${info.symbol}]`,
+        description: `${i + 1} / ${filtered.length} / ${tokens.length}`,
+      }))
+    },
+  })
+}
+
+function prettyRateLimiter(
+  state: RateLimiterState,
+  { decimals, symbol }: { decimals: number; symbol: string },
+) {
+  if (!state) return null
+  return {
+    capacity: formatUnits(state.capacity, decimals) + ' ' + symbol,
+    tokens: `${formatUnits(state.tokens, decimals)} (${Math.round((Number(state.tokens) / Number(state.capacity)) * 100)}%)`,
+    rate: `${formatUnits(state.rate, decimals)}/s (0-to-full in ${formatDuration(Number(state.capacity / state.rate))})`,
+    ...(state.tokens < state.capacity && {
+      timeToFull: formatDuration(Number(state.capacity - state.tokens) / Number(state.rate)),
+    }),
+  }
+}