@chainlink/ccip-cli 0.90.2 → 0.91.1

package/src/commands/send.ts

@@ -7,7 +7,6 @@ import {
   ChainFamily,
   bigIntReplacer,
   estimateExecGasForRequest,
-  fetchCCIPRequestsInTx,
   getDataBytes,
   networkInfo,
   sourceToDestTokenAmounts,
@@ -16,13 +15,24 @@ 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'
+import { type Ctx, Format } from './types.ts'
+import {
+  getCtx,
+  logParsedError,
+  parseTokenAmounts,
+  prettyRequest,
+  withDateTimestamp,
+} from './utils.ts'
+import { fetchChainsFromRpcs, loadChainWallet } from '../providers/index.ts'
 
 export const command = 'send <source> <router> <dest>'
 export const describe = 'Send a CCIP message from router on source to dest'
 
+/**
+ * Yargs builder for the send command.
+ * @param yargs - Yargs instance.
+ * @returns Configured yargs instance with command options.
+ */
 export const builder = (yargs: Argv) =>
   yargs
     .positional('source', {
@@ -123,26 +133,28 @@ export const builder = (yargs: Argv) =>
         !transferTokens || transferTokens.every((t) => /^[^=]+=\d+(\.\d+)?$/.test(t)),
     )
 
+/**
+ * Handler for the send command.
+ * @param argv - Command line arguments.
+ */
 export async function handler(argv: Awaited<ReturnType<typeof builder>['argv']> & GlobalOpts) {
-  let destroy
-  const destroy$ = new Promise((resolve) => {
-    destroy = resolve
-  })
-  return sendMessage(argv, destroy$)
+  const [controller, ctx] = getCtx(argv)
+  return sendMessage(ctx, argv)
     .catch((err) => {
       process.exitCode = 1
-      if (!logParsedError(err)) console.error(err)
+      if (!logParsedError.call(ctx, err)) ctx.logger.error(err)
     })
-    .finally(destroy)
+    .finally(() => controller.abort('Exited'))
 }
 
 async function sendMessage(
+  ctx: Ctx,
   argv: Awaited<ReturnType<typeof builder>['argv']> & GlobalOpts,
-  destroy: Promise<unknown>,
 ) {
+  const { logger } = ctx
   const sourceNetwork = networkInfo(argv.source)
   const destNetwork = networkInfo(argv.dest)
-  const getChain = fetchChainsFromRpcs(argv, undefined, destroy)
+  const getChain = fetchChainsFromRpcs(ctx, argv)
   const source = await getChain(sourceNetwork.name)
 
   let data: BytesLike
@@ -189,10 +201,12 @@ async function sendMessage(
     throw new Error('--token-receiver and --account intended only for Solana dest')
   }
 
+  let walletAddress, wallet
   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
+    ;[walletAddress, wallet] = await loadChainWallet(source, argv)
+    receiver = walletAddress // send to self if same family
   }
 
   if (argv.estimateGasLimit != null || argv.onlyEstimate) {
@@ -214,16 +228,17 @@ async function sendMessage(
       tokenAmounts,
     )
 
+    if (!walletAddress) [walletAddress, wallet] = await loadChainWallet(source, argv)
     const estimated = await estimateExecGasForRequest(source, dest, {
       lane,
       message: {
-        sender: await source.getWalletAddress(argv),
+        sender: walletAddress,
         receiver,
         data,
         tokenAmounts: destTokenAmounts,
       },
     })
-    console.log('Estimated gasLimit:', estimated)
+    logger.log('Estimated gasLimit:', estimated)
     argv.gasLimit = Math.ceil(estimated * (1 + (argv.estimateGasLimit ?? 0) / 100))
     if (argv.onlyEstimate) return
   }
@@ -247,8 +262,8 @@ async function sendMessage(
       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)
+      const feeTokens = await source.getFeeTokens(argv.router)
+      logger.debug('supported feeTokens:', feeTokens)
       for (const [token, info] of Object.entries(feeTokens)) {
         if (info.symbol === 'UNKNOWN' || info.symbol !== argv.feeToken) continue
         feeToken = token
@@ -273,7 +288,7 @@ async function sendMessage(
   // calculate fee
   const fee = await source.getFee(argv.router, destNetwork.chainSelector, message)
 
-  console.info(
+  logger.info(
     'Fee:',
     fee,
     '=',
@@ -284,33 +299,35 @@ async function sendMessage(
   )
   if (argv.onlyGetFee) return
 
-  const tx = await source.sendMessage(
+  if (!walletAddress) [walletAddress, wallet] = await loadChainWallet(source, argv)
+  const request = await source.sendMessage(
     argv.router,
     destNetwork.chainSelector,
     { ...message, fee },
-    argv,
+    { ...argv, wallet },
   )
-  console.log(
+  logger.info(
     '🚀 Sending message to',
-    tokenReceiver || receiver,
+    tokenReceiver && tokenReceiver !== '11111111111111111111111111111111'
+      ? tokenReceiver
+      : receiver,
     '@',
     destNetwork.name,
     ', tx =>',
-    tx.hash,
+    request.tx.hash,
+    ', messageId =>',
+    request.message.header.messageId,
   )
 
-  // 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))
+      logger.log(`message ${request.log.index} =`, withDateTimestamp(request))
       break
     case Format.pretty:
-      await prettyRequest(source, request)
+      await prettyRequest.call(ctx, source, request)
       break
     case Format.json:
-      console.info(JSON.stringify(request, bigIntReplacer, 2))
+      logger.info(JSON.stringify(request, bigIntReplacer, 2))
       break
   }
 }

package/src/commands/show.ts

@@ -2,18 +2,17 @@ import util from 'util'
 
 import {
   type CCIPRequest,
-  ChainFamily,
+  type ChainTransaction,
   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 { type Ctx, Format } from './types.ts'
 import {
+  getCtx,
   logParsedError,
   prettyCommit,
   prettyReceipt,
@@ -26,6 +25,11 @@ import { fetchChainsFromRpcs } from '../providers/index.ts'
 export const command = ['show <tx-hash>', '* <tx-hash>']
 export const describe = 'Show details of a CCIP request'
 
+/**
+ * Yargs builder for the show command.
+ * @param yargs - Yargs instance.
+ * @returns Configured yargs instance with command options.
+ */
 export const builder = (yargs: Argv) =>
   yargs
     .positional('tx-hash', {
@@ -41,50 +45,52 @@ export const builder = (yargs: Argv) =>
       },
       'id-from-source': {
         type: 'string',
-        describe: 'Search by messageId instead of txHash; requires specifying source network',
+        describe:
+          'Search by messageId instead of txHash; requires `[onRamp@]sourceNetwork` (onRamp address may be required in some chains)',
       },
     })
 
+/**
+ * Handler for the show command.
+ * @param argv - Command line arguments.
+ */
 export async function handler(argv: Awaited<ReturnType<typeof builder>['argv']> & GlobalOpts) {
-  let destroy
-  const destroy$ = new Promise((resolve) => {
-    destroy = resolve
-  })
-  return showRequests(argv, destroy$)
+  const [controller, ctx] = getCtx(argv)
+  return showRequests(ctx, argv)
     .catch((err) => {
       process.exitCode = 1
-      if (!logParsedError(err)) console.error(err)
+      if (!logParsedError.call(ctx, err)) ctx.logger.error(err)
     })
-    .finally(destroy)
+    .finally(() => controller.abort('Exited'))
 }
 
-async function showRequests(argv: Parameters<typeof handler>[0], destroy: Promise<unknown>) {
-  let source, getChain, tx, request: CCIPRequest
+async function showRequests(ctx: Ctx, argv: Parameters<typeof handler>[0]) {
+  const { logger } = ctx
+  let source, getChain, tx: ChainTransaction, 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`,
-      )
-    }
+    getChain = fetchChainsFromRpcs(ctx, argv)
+    let idFromSource, onRamp
+    if (argv.idFromSource.includes('@')) {
+      ;[onRamp, idFromSource] = argv.idFromSource.split('@')
+    } else idFromSource = argv.idFromSource
+    const sourceNetwork = networkInfo(idFromSource)
     source = await getChain(sourceNetwork.chainId)
-    request = await fetchCCIPMessageById(source, argv.txHash, argv)
+    if (!source.fetchRequestById)
+      throw new Error(`fetchRequestById not implemented for ${source.constructor.name}`)
+    request = await source.fetchRequestById(argv.txHash, onRamp, argv)
   } else {
-    const [getChain_, tx$] = fetchChainsFromRpcs(argv, argv.txHash, destroy)
+    const [getChain_, tx$] = fetchChainsFromRpcs(ctx, argv, argv.txHash)
     getChain = getChain_
-    tx = await tx$
-    source = tx.chain
-    request = await selectRequest(await fetchCCIPRequestsInTx(tx), 'to know more', argv)
+    ;[source, tx] = await tx$
+    request = await selectRequest(await source.fetchRequestsInTx(tx), 'to know more', argv)
   }
 
   const offchainTokenData = await source.fetchOffchainTokenData(request)
 
   switch (argv.format) {
     case Format.log: {
-      console.log(
+      logger.log(
         `message ${request.log.index} =`,
         withDateTimestamp(request),
         '\nattestations =',
@@ -93,48 +99,41 @@ async function showRequests(argv: Parameters<typeof handler>[0], destroy: Promis
       break
     }
     case Format.pretty:
-      await prettyRequest(source, request, offchainTokenData)
+      await prettyRequest.call(ctx, source, request, offchainTokenData)
       break
     case Format.json:
-      console.info(JSON.stringify({ ...request, offchainTokenData }, bigIntReplacer, 2))
+      logger.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 offRamp = await discoverOffRamp(source, dest, request.lane.onRamp, source)
   const commitStore = await dest.getCommitStoreForOffRamp(offRamp)
 
   const commit = await dest.fetchCommitReport(commitStore, request, argv)
   switch (argv.format) {
     case Format.log:
-      console.log('commit =', commit)
+      logger.log('commit =', commit)
       break
     case Format.pretty:
-      await prettyCommit(dest, commit, request)
+      await prettyCommit.call(ctx, dest, commit, request)
       break
     case Format.json:
-      console.info(JSON.stringify(commit, bigIntReplacer, 2))
+      logger.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,
-    },
-  )) {
+  for await (const receipt of dest.fetchExecutionReceipts(offRamp, request, commit, argv)) {
     switch (argv.format) {
       case Format.log:
-        console.log('receipt =', withDateTimestamp(receipt))
+        logger.log('receipt =', withDateTimestamp(receipt))
         break
       case Format.pretty:
-        if (!found) console.info('Receipts (dest):')
-        prettyReceipt(
+        if (!found) logger.info('Receipts (dest):')
+        prettyReceipt.call(
+          ctx,
           receipt,
           request,
           receipt.log.tx?.from ??
@@ -142,10 +141,10 @@ async function showRequests(argv: Parameters<typeof handler>[0], destroy: Promis
         )
         break
       case Format.json:
-        console.info(JSON.stringify(receipt, bigIntReplacer, 2))
+        logger.info(JSON.stringify(receipt, bigIntReplacer, 2))
         break
     }
     found = true
   }
-  if (!found) console.warn(`No execution receipt found for request`)
+  if (!found) logger.warn(`No execution receipt found for request`)
 }

package/src/commands/supported-tokens.ts

@@ -19,8 +19,6 @@
  * - Individual token failures don't halt the process
  * - Errors are collected and reported comprehensively
  * - Detailed error reporting for debugging
- *
- * @module supported-tokens
  */
 
 import {
@@ -33,8 +31,8 @@ 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 Ctx, Format } from './types.ts'
+import { formatDuration, getCtx, logParsedError, prettyTable } from './utils.ts'
 import type { GlobalOpts } from '../index.ts'
 import { fetchChainsFromRpcs } from '../providers/index.ts'
 
@@ -42,6 +40,11 @@ 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'
 
+/**
+ * Yargs builder for the supported-tokens command.
+ * @param yargs - Yargs instance.
+ * @returns Configured yargs instance with command options.
+ */
 export const builder = (yargs: Argv) =>
   yargs
     .positional('source', {
@@ -62,22 +65,24 @@ export const builder = (yargs: Argv) =>
         'If address is router/onramp/tokenAdminRegistry, token may be used to pre-select a token from the supported list',
     })
 
+/**
+ * Handler for the supported-tokens command.
+ * @param argv - Command line arguments.
+ */
 export async function handler(argv: Awaited<ReturnType<typeof builder>['argv']> & GlobalOpts) {
-  let destroy
-  const destroy$ = new Promise((resolve) => {
-    destroy = resolve
-  })
-  return getSupportedTokens(argv, destroy$)
+  const [controller, ctx] = getCtx(argv)
+  return getSupportedTokens(ctx, argv)
     .catch((err) => {
       process.exitCode = 1
-      if (!logParsedError(err)) console.error(err)
+      if (!logParsedError.call(ctx, err)) ctx.logger.error(err)
     })
-    .finally(destroy)
+    .finally(() => controller.abort('Exited'))
 }
 
-async function getSupportedTokens(argv: Parameters<typeof handler>[0], destroy: Promise<unknown>) {
+async function getSupportedTokens(ctx: Ctx, argv: Parameters<typeof handler>[0]) {
+  const { logger } = ctx
   const sourceNetwork = networkInfo(argv.source)
-  const getChain = fetchChainsFromRpcs(argv, undefined, destroy)
+  const getChain = fetchChainsFromRpcs(ctx, argv)
   const source = await getChain(sourceNetwork.name)
   let registry
   try {
@@ -88,21 +93,21 @@ async function getSupportedTokens(argv: Parameters<typeof handler>[0], destroy:
 
   let info, tokenPool, poolConfigs, registryConfig
   if (registry && !argv.token) {
-    const feeTokens = await source.listFeeTokens(argv.address)
+    const feeTokens = await source.getFeeTokens(argv.address)
     switch (argv.format) {
       case Format.pretty:
-        console.info('Fee Tokens:')
-        console.table(feeTokens)
+        logger.info('Fee Tokens:')
+        logger.table(feeTokens)
         break
       case Format.json:
-        console.log(JSON.stringify(feeTokens, null, 2))
+        logger.log(JSON.stringify(feeTokens, null, 2))
         break
       default:
-        console.log('feeTokens:', feeTokens)
+        logger.log('feeTokens:', feeTokens)
     }
 
     // router + interactive list
-    info = await listTokens(source, registry, argv)
+    info = await listTokens(ctx, source, registry, argv)
     if (!info) return // format != pretty
     registryConfig = await source.getRegistryTokenConfig(registry, info.token)
     tokenPool = registryConfig.tokenPool
@@ -134,18 +139,18 @@ async function getSupportedTokens(argv: Parameters<typeof handler>[0], destroy:
     }
 
     if (argv.format === Format.json) {
-      console.log(JSON.stringify({ ...info, tokenPool, ...poolConfigs }, bigIntReplacer, 2))
+      logger.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)
+      logger.log('Token:', poolConfigs.token, info)
+      logger.log('Token Pool:', tokenPool)
+      logger.log('Pool Configs:', poolConfigs)
       return
     }
   }
   const remotes = await source.getTokenPoolRemotes(tokenPool)
 
-  prettyTable({
+  prettyTable.call(ctx, {
     network: `${source.network.name} [${source.network.chainSelector}]`,
     token: poolConfigs.token,
     symbol: info.symbol,
@@ -161,9 +166,9 @@ async function getSupportedTokens(argv: Parameters<typeof handler>[0], destroy:
     }),
   })
   const remotesLen = Object.keys(remotes).length
-  if (remotesLen > 0) console.info('Remotes [', remotesLen, ']:')
+  if (remotesLen > 0) logger.info('Remotes [', remotesLen, ']:')
   for (const [network, remote] of Object.entries(remotes))
-    prettyTable({
+    prettyTable.call(ctx, {
       remoteNetwork: `${network} [${networkInfo(network).chainSelector}]`,
       remoteToken: remote.remoteToken,
       remotePool: remote.remotePools,
@@ -172,7 +177,7 @@ async function getSupportedTokens(argv: Parameters<typeof handler>[0], destroy:
     })
 }
 
-async function listTokens(source: Chain, registry: string, argv: GlobalOpts) {
+async function listTokens({ logger }: Ctx, 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
@@ -185,12 +190,12 @@ async function listTokens(source: Chain, registry: string, argv: GlobalOpts) {
               const res = { token, ...info }
               if (argv.format === Format.log) {
                 // Format.log prints out-of-order, as it fetches data, concurrently
-                console.info(token, '=', info)
+                logger.info(token, '=', info)
               }
               return res
             },
             (err) => {
-              console.debug(`getTokenInfo errored`, token, err)
+              logger.debug(`getTokenInfo errored`, token, err)
             },
           ),
         ),
@@ -199,7 +204,7 @@ async function listTokens(source: Chain, registry: string, argv: GlobalOpts) {
     if (argv.format === Format.json) {
       // Format.json keeps order, prints newline-separated objects
       for (const info of infos_) {
-        console.log(JSON.stringify(info))
+        logger.log(JSON.stringify(info))
       }
     }
     infos.push(...infos_)

package/src/commands/types.ts

@@ -1,6 +1,21 @@
+import type { Logger } from '@chainlink/ccip-sdk/src/types.js'
+
+/** Output format options for CLI commands. */
 export const Format = {
   log: 'log',
   pretty: 'pretty',
   json: 'json',
 } as const
+/** Type for output format selection. */
 export type Format = (typeof Format)[keyof typeof Format]
+
+/**
+ * Command context
+ */
+export type Ctx = {
+  destroy$: AbortSignal
+  logger: Logger & {
+    table: (tabularData: unknown, properties?: readonly string[]) => void
+    log: (...args: unknown[]) => void
+  }
+}