@chainlink/ccip-cli 0.96.0 → 0.97.0

package/src/commands/utils.ts

@@ -1,9 +1,9 @@
 import { Console } from 'node:console'
 
 import {
-  type CCIPCommit,
   type CCIPExecution,
   type CCIPRequest,
+  type CCIPVerifications,
   type Chain,
   type ChainFamily,
   type ChainStatic,
@@ -18,7 +18,6 @@ import {
 } from '@chainlink/ccip-sdk/src/index.ts'
 import { select } from '@inquirer/prompts'
 import {
-  dataLength,
   formatUnits,
   hexlify,
   isBytesLike,
@@ -125,14 +124,17 @@ export function formatDisplayTxHash(hash: string, family: ChainFamily): string {
 }
 
 async function formatToken(
-  source: Chain,
-  ta: { amount: bigint } & ({ token: string } | { sourcePoolAddress: string }),
+  source: Chain | undefined,
+  ta: { amount: bigint } & (
+    | { token: string }
+    | { sourceTokenAddress?: string; sourcePoolAddress: string }
+  ),
 ): Promise<string> {
+  if (!source) return `${ta.amount} ${'sourcePoolAddress' in ta ? ta.sourcePoolAddress : ta.token}`
   let token
   if ('token' in ta) token = ta.token
-  else {
-    token = await source.getTokenForTokenPool(ta.sourcePoolAddress)
-  }
+  else if (ta.sourceTokenAddress) token = ta.sourceTokenAddress
+  else token = await source.getTokenForTokenPool(ta.sourcePoolAddress)
   const { symbol, decimals } = await source.getTokenInfo(token)
   return `${formatUnits(ta.amount, decimals)} ${symbol}`
 }
@@ -143,21 +145,37 @@ async function formatToken(
  * @param values - Array values to format.
  * @returns Record with indexed keys.
  */
-export function formatArray<T>(name: string, values: readonly T[]): Record<string, T> {
+export function formatArray<T>(
+  name: string,
+  values: readonly T[],
+  edges = '[]',
+): Record<string, T> {
   if (values.length <= 1) return { [name]: values[0]! }
-  return Object.fromEntries(values.map((v, i) => [`${name}[${i}]`, v] as const))
+  return Object.fromEntries(values.map((v, i) => [`${name}${edges[0]}${i}${edges[1]}`, v] as const))
 }
 
 // join truthy property names, separated by a dot
-function j(...args: string[]): string {
-  return args.filter(Boolean).join('.')
+function j(...args: (string | number)[]): string {
+  return args.reduce(
+    (acc: string, v): string =>
+      v === ''
+        ? acc
+        : acc
+          ? acc + (typeof v === 'number' ? `[${v}]` : (v.match(/^\w/) ? '.' : '') + v)
+          : v.toString(),
+    '',
+  )
 }
 
 function formatData(name: string, data: string, parseError = false): Record<string, string> {
   if (parseError) {
     let parsed
     for (const chain of Object.values(supportedChains)) {
-      parsed = chain.parse?.(data)
+      try {
+        parsed = chain.parse?.(data)
+      } catch {
+        // ignore
+      }
       if (parsed) break
     }
     if (parsed) {
@@ -176,7 +194,7 @@ function formatData(name: string, data: string, parseError = false): Record<stri
     for (let i = data.length; i > 2; i -= 64) {
       split.unshift(data.substring(Math.max(i - 64, 0), i))
     }
-  return formatArray(name, split)
+  return formatArray(name, split, '{}')
 }
 
 function formatDate(timestamp: number) {
@@ -238,20 +256,21 @@ function formatDataString(data: string): Record<string, string> {
 
 /**
  * Prints a CCIP request in a human-readable format.
- * @param source - Source chain instance.
  * @param request - CCIP request to print.
+ * @param source - Source chain instance.
  */
-export async function prettyRequest(this: Ctx, source: Chain, request: CCIPRequest) {
+export async function prettyRequest(this: Ctx, request: CCIPRequest, source?: Chain) {
   prettyLane.call(this, request.lane)
   this.logger.info('Request (source):')
 
   let finalized
   try {
-    finalized = await source.getBlockTimestamp('finalized')
+    if (source) finalized = await source.getBlockTimestamp('finalized')
   } catch (_) {
     // no finalized tag support
   }
-  const nonce = Number(request.message.nonce)
+  let nonce
+  if ('nonce' in request.message) nonce = Number(request.message.nonce)
 
   const sourceFamily = networkInfo(request.lane.sourceChainSelector).family
   const destFamily = networkInfo(request.lane.destChainSelector).family
@@ -280,6 +299,8 @@ export async function prettyRequest(this: Ctx, source: Chain, request: CCIPReque
     'destChainSelector',
     'extraArgs',
     'accounts',
+    'receipts',
+    'encodedMessage',
   )
   prettyTable.call(this, {
     messageId: request.message.messageId,
@@ -287,7 +308,7 @@ export async function prettyRequest(this: Ctx, source: Chain, request: CCIPReque
     sender: displaySender,
     receiver: displayReceiver,
     sequenceNumber: Number(request.message.sequenceNumber),
-    nonce: nonce === 0 ? '0 => allow out-of-order exec' : nonce,
+    ...(nonce != null && { nonce: nonce === 0 ? '0 => allow out-of-order exec' : nonce }),
     ...('gasLimit' in request.message
       ? { gasLimit: Number(request.message.gasLimit) }
       : 'computeUnits' in request.message
@@ -312,37 +333,53 @@ export async function prettyRequest(this: Ctx, source: Chain, request: CCIPReque
     ),
     ...formatDataString(request.message.data),
     ...('accounts' in request.message ? formatArray('accounts', request.message.accounts) : {}),
+    ...('receipts' in request.message ? formatArray('receipts', request.message.receipts) : {}),
     ...rest,
   })
   this.logger.info('CCIP Explorer:', getCCIPExplorerUrl('msg', request.message.messageId))
 }
 
 /**
- * Prints a CCIP commit in a human-readable format.
+ * Prints CCIP Verifications in a human-readable format.
  * @param dest - Destination chain instance.
- * @param commit - CCIP commit to print.
+ * @param verifications - CCIP verifications to print.
  * @param request - CCIP request for timestamp comparison.
  */
-export async function prettyCommit(
+export async function prettyVerifications(
   this: Ctx,
   dest: Chain,
-  commit: CCIPCommit,
+  verifications: CCIPVerifications,
   request: PickDeep<CCIPRequest, 'tx.timestamp' | 'lane.destChainSelector'>,
 ) {
-  const timestamp = await dest.getBlockTimestamp(commit.log.blockNumber)
   const destFamily = networkInfo(request.lane.destChainSelector).family
-  const origin = commit.log.tx?.from ?? (await dest.getTransaction(commit.log.transactionHash)).from
 
-  prettyTable.call(this, {
-    merkleRoot: commit.report.merkleRoot,
-    min: Number(commit.report.minSeqNr),
-    max: Number(commit.report.maxSeqNr),
-    origin: formatDisplayAddress(origin, destFamily),
-    contract: formatDisplayAddress(commit.log.address, destFamily),
-    transactionHash: formatDisplayTxHash(commit.log.transactionHash, destFamily),
-    blockNumber: commit.log.blockNumber,
-    timestamp: `${formatDate(timestamp)} (${formatDuration(timestamp - request.tx.timestamp)} after request)`,
-  })
+  if ('report' in verifications) {
+    const timestamp = await dest.getBlockTimestamp(verifications.log.blockNumber)
+    const origin =
+      verifications.log.tx?.from ??
+      (await dest.getTransaction(verifications.log.transactionHash)).from
+    prettyTable.call(this, {
+      merkleRoot: verifications.report.merkleRoot,
+      min: Number(verifications.report.minSeqNr),
+      max: Number(verifications.report.maxSeqNr),
+      origin: formatDisplayAddress(origin, destFamily),
+      contract: formatDisplayAddress(verifications.log.address, destFamily),
+      transactionHash: formatDisplayTxHash(verifications.log.transactionHash, destFamily),
+      blockNumber: verifications.log.blockNumber,
+      timestamp: `${formatDate(timestamp)} (${formatDuration(timestamp - request.tx.timestamp)} after request)`,
+    })
+  } else {
+    let ts = 0
+    for (const { timestamp } of verifications.verifications)
+      if (timestamp && timestamp > ts) ts = timestamp
+
+    prettyTable.call(this, {
+      ...verifications,
+      ...(ts && {
+        timestamp: `${formatDate(ts)} (${formatDuration(ts - request.tx.timestamp)} after request)`,
+      }),
+    })
+  }
 }
 
 /**
@@ -401,6 +438,18 @@ function wrapText(text: string, maxWidth: number, threshold: number = 0.1): stri
   return lines
 }
 
+function flatten(val: unknown, path: (string | number)[] = []): [(string | number)[], unknown][] {
+  if (Array.isArray(val)) {
+    if (val.length) return val.map((v: unknown, i: number) => flatten(v, [...path, i])).flat(1)
+  } else if (val && typeof val === 'object') {
+    if (Object.keys(val).length === 0) return [[path, val]]
+    return Object.entries(val)
+      .map(([k, v]) => flatten(v, [...path, k]))
+      .flat(1)
+  }
+  return [[path, val]]
+}
+
 /**
  * Prints a formatted table of key-value pairs.
  * @param args - Key-value pairs to print.
@@ -412,23 +461,29 @@ export function prettyTable(
   opts = { parseErrorKeys: ['returnData'], spcount: 0 },
 ) {
   const out: (readonly [string, unknown])[] = []
-  for (const [key, value] of Object.entries(args)) {
+  for (const [path, value] of flatten(args)) {
+    const last = path[path.length - 1]
+    const key = j(...path)
     if (isBytesLike(value)) {
       let parseError
-      if (opts.parseErrorKeys.includes(key)) parseError = true
-      if (dataLength(value) <= 32 && !parseError) out.push([key, value])
-      else out.push(...Object.entries(formatData(key, hexlify(value), parseError)))
+      if (opts.parseErrorKeys.includes(path[path.length - 1]!.toString())) parseError = true
+      out.push(
+        ...Object.entries(
+          formatData(key, typeof value !== 'string' ? hexlify(value) : value, parseError),
+        ),
+      )
     } else if (typeof value === 'string') {
       out.push(
         ...wrapText(value, Math.max(100, +(process.env.COLUMNS || 80) * 0.9)).map(
           (l, i) => [!i ? key : ' '.repeat(opts.spcount++), l] as const,
         ),
       )
-    } else if (Array.isArray(value)) {
-      if (value.length <= 1) out.push([key, value[0] as unknown])
-      else out.push(...value.map((v, i) => [`${key}[${i}]`, v as unknown] as const))
-    } else if (value && typeof value === 'object') {
-      out.push(...Object.entries(value).map(([k, v]) => [`${key}.${k}`, v] as const))
+    } else if (
+      typeof last === 'string' &&
+      last.toLowerCase().includes('timestamp') &&
+      typeof value === 'number'
+    ) {
+      out.push([key, formatDate(value)])
     } else out.push([key, value])
   }
   return this.logger.table(Object.fromEntries(out))
@@ -477,6 +532,13 @@ export function formatCCIPError(err: unknown, verbose = false): string | null {
 
   lines.push(`error[${err.code}]: ${err.message}`)
 
+  if (Object.keys(err.context).length > 0) {
+    lines.push('  context:')
+    for (const [key, value] of Object.entries(err.context)) {
+      lines.push(`    ${key}: ${value as string}`)
+    }
+  }
+
   if (err.recovery) {
     lines.push(`  help: ${err.recovery}`)
   }

package/src/index.ts

@@ -11,7 +11,7 @@ import { Format } from './commands/index.ts'
 util.inspect.defaultOptions.depth = 6 // print down to tokenAmounts in requests
 // generate:nofail
 // `const VERSION = '${require('./package.json').version}-${require('child_process').execSync('git rev-parse --short HEAD').toString().trim()}'`
-const VERSION = '0.96.0-983178a'
+const VERSION = '0.97.0-8811550'
 // generate:end
 
 const globalOpts = {

package/src/loadtest.ts

@@ -0,0 +1,171 @@
+import { ChainFamily, networkInfo } from '@chainlink/ccip-sdk/src/index.ts'
+import { formatUnits, toUtf8Bytes } from 'ethers'
+
+import { getCtx } from './commands/utils.ts'
+import { fetchChainsFromRpcs, loadChainWallet } from './providers/index.ts'
+
+const DEST = networkInfo('ethereum-testnet-sepolia-base-1')
+const RECEIVER = '0x'
+const RPCS_FILE = '../../.env'
+const RPCS = [
+  'https://ethereum-sepolia-rpc.publicnode.com',
+  'https://avalanche-fuji-c-chain-rpc.publicnode.com',
+]
+const PRIVATE_KEYS = {
+  [ChainFamily.Solana]: process.env['PRIVATE_KEY_SOLANA'],
+  [ChainFamily.Aptos]: process.env['PRIVATE_KEY_APTOS'],
+  [ChainFamily.EVM]: process.env['PRIVATE_KEY'],
+}
+
+// mapping of source_network_name to its router
+const SOURCES: Record<string, string> = {
+  'avalanche-testnet-fuji': '0xF694E193200268f9a4868e4Aa017A0118C9a8177',
+}
+// per source:
+const MAX_COUNT = 100
+const MAX_INFLIGHT = 10 // inflight on RPC (tx to be accepted/included), not on CCIP
+const MAX_PER_SECOND = 1
+
+/** like Promise.all, but receives Promise factories and spawn a maximum number of them in parallel */
+function promiseAllMax<T>(
+  promises: readonly (() => Promise<T>)[],
+  maxParallelJobs: number,
+  cancel?: Promise<unknown>,
+): Promise<T[]> {
+  return new Promise((resolve, reject) => {
+    const results = new Array(promises.length) as T[]
+    let completed = 0
+    let started = 0
+    let rejected = false
+
+    if (promises.length === 0) {
+      resolve([])
+      return
+    }
+
+    const startNext = () => {
+      if (rejected || started >= promises.length) return
+
+      const index = started++
+      const promiseFactory = promises[index]!
+
+      promiseFactory()
+        .then((result) => {
+          if (rejected) return
+          results[index] = result
+          completed++
+
+          if (completed === promises.length) {
+            resolve(results)
+          } else {
+            startNext()
+          }
+        })
+        .catch((err) => {
+          rejected = true
+          reject(err as Error)
+        })
+    }
+
+    // Handle cancellation
+    void cancel?.then(() => {
+      if (!rejected && completed < promises.length) {
+        rejected = true
+        // eslint-disable-next-line no-restricted-syntax
+        reject(new Error('Cancelled'))
+      }
+    })
+
+    // Start up to maxParallelJobs promises
+    for (let i = 0; i < maxParallelJobs && i < promises.length; i++) {
+      startNext()
+    }
+  })
+}
+
+async function main() {
+  const [ctx] = getCtx({ verbose: !!process.env['CCIP_VERBOSE'] })
+  const { logger } = ctx
+  const getChain = fetchChainsFromRpcs(ctx, {
+    noApi: true,
+    rpcsFile: RPCS_FILE,
+    rpcs: RPCS,
+  })
+  const allLanes = []
+  for (const [name, router] of Object.entries(SOURCES)) {
+    const source = await getChain(name)
+    const [walletAddr, wallet] = await loadChainWallet(source, {
+      wallet: PRIVATE_KEYS[source.network.family as keyof typeof PRIVATE_KEYS],
+    })
+    const initialBalance = await source.getBalance({ holder: walletAddr })
+    const nativeToken = await source.getNativeTokenForRouter(router)
+    const nativeInfo = await source.getTokenInfo(nativeToken)
+    const symbol = nativeInfo.symbol.startsWith('W')
+      ? nativeInfo.symbol.substring(1)
+      : nativeInfo.symbol
+    logger.info(
+      `Initial balance of ${walletAddr} @ ${name}:`,
+      initialBalance,
+      '=',
+      formatUnits(initialBalance, nativeInfo.decimals),
+      symbol,
+    )
+
+    const startTime = performance.now()
+    let inflight = 0,
+      completed = 0
+    const tasks = Array.from({ length: MAX_COUNT }, (_, i) => async () => {
+      const deltaMs = performance.now() - startTime
+      const delay = (1e3 * completed) / MAX_PER_SECOND - deltaMs
+      if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay))
+
+      inflight++
+      const req = await source.sendMessage({
+        router,
+        destChainSelector: DEST.chainSelector,
+        message: {
+          receiver: RECEIVER,
+          data: toUtf8Bytes(`ccip-cli load test: ${i + 1}/${MAX_COUNT}`),
+          extraArgs: { gasLimit: 0n },
+        },
+        wallet,
+      })
+      inflight--
+      completed++
+      logger.info(`[${i + 1}] LOAD TEST`, name, '=>', DEST.name, {
+        inflight,
+        completed,
+        total: MAX_COUNT,
+        messageId: req.message.messageId,
+        tx: req.log.transactionHash,
+      })
+    })
+    allLanes.push(
+      promiseAllMax(tasks, MAX_INFLIGHT).then(async () => {
+        const finalBalance = await source.getBalance({ holder: walletAddr })
+        logger.info(
+          `Final balance of ${walletAddr} @ ${name}:`,
+          finalBalance,
+          '=',
+          formatUnits(finalBalance, nativeInfo.decimals),
+          symbol,
+          ', spent =',
+          formatUnits(initialBalance - finalBalance, nativeInfo.decimals),
+        )
+        const delta = (performance.now() - startTime) / 1e3
+        logger.warn(
+          `[${name}] Sent`,
+          completed,
+          `requests in`,
+          delta,
+          `seconds =~`,
+          completed / delta,
+          `reqs/s`,
+        )
+      }),
+    )
+  }
+  await Promise.all(allLanes)
+}
+
+await main()