@chainlink/ccip-cli 0.93.0 → 0.95.0

package/src/commands/token.ts

@@ -0,0 +1,132 @@
+/**
+ * Token balance query command.
+ * Queries native or token balance for an address.
+ */
+
+import { type ChainStatic, networkInfo } from '@chainlink/ccip-sdk/src/index.ts'
+import { formatUnits } from 'ethers'
+import type { Argv } from 'yargs'
+
+import { type Ctx, Format } from './types.ts'
+import { getCtx, logParsedError, prettyTable } from './utils.ts'
+import type { GlobalOpts } from '../index.ts'
+import { fetchChainsFromRpcs } from '../providers/index.ts'
+
+export const command = 'token'
+export const describe = 'Query token balance for an address'
+
+/**
+ * Yargs builder for the token command.
+ * @param yargs - Yargs instance.
+ * @returns Configured yargs instance with command options.
+ */
+export const builder = (yargs: Argv) =>
+  yargs
+    .option('network', {
+      alias: 'n',
+      type: 'string',
+      demandOption: true,
+      describe: 'Network: chainId or name (e.g., ethereum-mainnet, solana-devnet)',
+    })
+    .option('holder', {
+      alias: 'H',
+      type: 'string',
+      demandOption: true,
+      describe: 'Wallet address to query balance for',
+    })
+    .option('token', {
+      alias: 't',
+      type: 'string',
+      demandOption: false,
+      describe: 'Token address (omit for native token balance)',
+    })
+    .example([
+      ['ccip-cli token -n ethereum-mainnet -H 0x1234...abcd', 'Query native ETH balance'],
+      [
+        'ccip-cli token -n ethereum-mainnet -H 0x1234... -t 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        'Query USDC token balance',
+      ],
+      [
+        'ccip-cli token -n solana-devnet -H EPUjBP3Xf76K1VKsDSc6GupBWE8uykNksCLJgXZn87CB',
+        'Query native SOL balance',
+      ],
+    ])
+
+/**
+ * Handler for the token command.
+ * @param argv - Command line arguments.
+ */
+export async function handler(argv: Awaited<ReturnType<typeof builder>['argv']> & GlobalOpts) {
+  const [ctx, destroy] = getCtx(argv)
+  return queryTokenBalance(ctx, argv)
+    .catch((err) => {
+      process.exitCode = 1
+      if (!logParsedError.call(ctx, err)) ctx.logger.error(err)
+    })
+    .finally(destroy)
+}
+
+async function queryTokenBalance(ctx: Ctx, argv: Parameters<typeof handler>[0]) {
+  const { logger } = ctx
+  const networkName = networkInfo(argv.network).name
+  const getChain = fetchChainsFromRpcs(ctx, argv)
+  const chain = await getChain(networkName)
+
+  const balance = await chain.getBalance({
+    holder: argv.holder,
+    token: argv.token,
+  })
+
+  // Get token info for formatting (only for tokens, not native)
+  let tokenInfo
+  if (argv.token) {
+    argv.token = (chain.constructor as ChainStatic).getAddress(argv.token)
+    tokenInfo = await chain.getTokenInfo(argv.token)
+  }
+
+  const tokenLabel = tokenInfo?.symbol ?? 'native'
+  const formatted = formatUnits(
+    balance,
+    tokenInfo ? tokenInfo.decimals : (chain.constructor as ChainStatic).decimals,
+  )
+
+  switch (argv.format) {
+    case Format.json:
+      logger.log(
+        JSON.stringify(
+          {
+            network: networkName,
+            holder: argv.holder,
+            token: tokenLabel,
+            balance: balance.toString(),
+            formatted,
+            ...tokenInfo,
+          },
+          null,
+          2,
+        ),
+      )
+      return
+    case Format.log:
+      logger.log(
+        `Balance of`,
+        tokenInfo ? argv.token : tokenLabel,
+        ':',
+        balance,
+        `=`,
+        tokenInfo ? `${formatted} ${tokenLabel}` : formatted,
+      )
+      return
+    case Format.pretty:
+    default:
+      prettyTable.call(ctx, {
+        network: networkName,
+        holder: argv.holder,
+        token: argv.token ?? tokenLabel,
+        balance,
+        formatted,
+        ...tokenInfo,
+      })
+      return
+  }
+}

package/src/commands/utils.ts

@@ -12,6 +12,7 @@ import {
   CCIPErrorCode,
   ExecutionState,
   getCCIPExplorerUrl,
+  getDataBytes,
   networkInfo,
   supportedChains,
 } from '@chainlink/ccip-sdk/src/index.ts'
@@ -19,11 +20,11 @@ import { select } from '@inquirer/prompts'
 import {
   dataLength,
   formatUnits,
-  getBytes,
   hexlify,
   isBytesLike,
   isHexString,
   parseUnits,
+  toBigInt,
   toUtf8String,
 } from 'ethers'
 import type { PickDeep } from 'type-fest'
@@ -215,6 +216,26 @@ function omit<T extends Record<string, unknown>, K extends string>(
   return result
 }
 
+// while formatData just breaks 0x bytes into 32B chunks for readability, this function first
+// tests if the data looks like a UTF-8 string (with length prefix) and decode that before
+function formatDataString(data: string): Record<string, string> {
+  const bytes = getDataBytes(data)
+  const isPrintableChars = (bytes_: Uint8Array) => bytes_.every((b) => 32 <= b && b <= 126)
+  if (bytes.length > 64 && toBigInt(bytes.subarray(0, 32)) === 32n) {
+    const len = toBigInt(bytes.subarray(32, 64))
+    if (
+      len < 512 &&
+      bytes.length - 64 === Math.ceil(Number(len) / 32) * 32 &&
+      isPrintableChars(bytes.subarray(64, 64 + Number(len))) &&
+      bytes.subarray(64 + Number(len)).every((b) => b === 0)
+    ) {
+      return { data: toUtf8String(bytes.subarray(64, 64 + Number(len))) }
+    }
+  }
+  if (bytes.length > 0 && isPrintableChars(bytes)) return { data: toUtf8String(bytes) }
+  return formatData('data', data)
+}
+
 /**
  * Prints a CCIP request in a human-readable format.
  * @param source - Source chain instance.
@@ -289,11 +310,7 @@ export async function prettyRequest(this: Ctx, source: Chain, request: CCIPReque
       'tokens',
       await Promise.all(request.message.tokenAmounts.map(formatToken.bind(null, source))),
     ),
-    ...(isBytesLike(request.message.data) &&
-    dataLength(request.message.data) > 0 &&
-    getBytes(request.message.data).every((b) => 32 <= b && b <= 126) // printable characters
-      ? { data: toUtf8String(request.message.data) }
-      : formatData('data', request.message.data)),
+    ...formatDataString(request.message.data),
     ...('accounts' in request.message ? formatArray('accounts', request.message.accounts) : {}),
     ...rest,
   })

package/src/index.ts

@@ -11,13 +11,13 @@ 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.93.0-e6b317b'
+const VERSION = '0.95.0-5f1a7cb'
 // generate:end
 
 const globalOpts = {
   rpcs: {
     type: 'array',
-    alias: ['r', 'rpc'],
+    alias: 'rpc',
     describe: 'List of RPC endpoint URLs, ws[s] or http[s]',
     string: true,
   },

package/src/providers/index.ts

@@ -8,10 +8,10 @@ import {
   type EVMChain,
   type TONChain,
   CCIPChainFamilyUnsupportedError,
-  CCIPNetworkFamilyUnsupportedError,
   CCIPRpcNotFoundError,
   CCIPTransactionNotFoundError,
   ChainFamily,
+  NetworkType,
   networkInfo,
   supportedChains,
 } from '@chainlink/ccip-sdk/src/index.ts'
@@ -94,7 +94,7 @@ export function fetchChainsFromRpcs(
   const loadChainFamily = (F: ChainFamily, txHash?: string) =>
     (initFamily$[F] ??= (endpoints$ ??= collectEndpoints.call(ctx, argv)).then((endpoints) => {
       const C = supportedChains[F]
-      if (!C) throw new CCIPNetworkFamilyUnsupportedError(F)
+      if (!C) throw new CCIPChainFamilyUnsupportedError(F)
       ctx.logger.debug('Racing', endpoints.size, 'RPC endpoints for', F)
 
       const chains$: Promise<Chain>[] = []
@@ -214,7 +214,11 @@ export async function loadChainWallet(chain: Chain, argv: { wallet?: unknown; rp
       wallet = loadSuiWallet(argv)
       return [wallet.toSuiAddress(), wallet] as const
     case ChainFamily.TON:
-      wallet = await loadTonWallet((chain as TONChain).provider, argv, chain.network.isTestnet)
+      wallet = await loadTonWallet(
+        (chain as TONChain).provider,
+        argv,
+        chain.network.networkType === NetworkType.Testnet,
+      )
       return [wallet.getAddress(), wallet] as const
     default:
       // TypeScript exhaustiveness check - this should never be reached