@chainlink/ccip-cli 0.92.0 → 0.93.0

package/src/commands/send.ts

@@ -296,7 +296,11 @@ async function sendMessage(
   }
 
   // calculate fee
-  const fee = await source.getFee(argv.router, destNetwork.chainSelector, message)
+  const fee = await source.getFee({
+    ...argv,
+    destChainSelector: destNetwork.chainSelector,
+    message,
+  })
 
   logger.info(
     'Fee:',
@@ -310,12 +314,12 @@ async function sendMessage(
   if (argv.onlyGetFee) return
 
   if (!walletAddress) [walletAddress, wallet] = await loadChainWallet(source, argv)
-  const request = await source.sendMessage(
-    argv.router,
-    destNetwork.chainSelector,
-    { ...message, fee },
-    { ...argv, wallet },
-  )
+  const request = await source.sendMessage({
+    ...argv,
+    destChainSelector: destNetwork.chainSelector,
+    message: { ...message, fee },
+    wallet,
+  })
   logger.info(
     '🚀 Sending message to',
     tokenReceiver && tokenReceiver !== '11111111111111111111111111111111'
@@ -328,7 +332,6 @@ async function sendMessage(
     ', messageId =>',
     request.message.messageId,
   )
-
   await showRequests(ctx, {
     ...argv,
     txHash: request.tx.hash,

package/src/commands/show.ts

@@ -3,6 +3,8 @@ import {
   type ChainTransaction,
   CCIPExecTxRevertedError,
   CCIPNotImplementedError,
+  ExecutionState,
+  MessageStatus,
   bigIntReplacer,
   discoverOffRamp,
   isSupportedTxHash,
@@ -82,18 +84,18 @@ export async function showRequests(ctx: Ctx, argv: Parameters<typeof handler>[0]
     getChain = fetchChainsFromRpcs(ctx, argv)
     let idFromSource, onRamp
     if (argv.idFromSource.includes('@')) {
-      ;[onRamp, idFromSource] = argv.idFromSource.split('@')
+      ;[onRamp, idFromSource] = argv.idFromSource.split('@') as [string, string]
     } else idFromSource = argv.idFromSource
     const sourceNetwork = networkInfo(idFromSource)
     source = await getChain(sourceNetwork.chainId)
-    if (!source.fetchRequestById)
-      throw new CCIPNotImplementedError(`fetchRequestById for ${source.constructor.name}`)
-    request = await source.fetchRequestById(argv.txHash, onRamp, argv)
+    if (!source.getMessageById)
+      throw new CCIPNotImplementedError(`getMessageById for ${source.constructor.name}`)
+    request = await source.getMessageById(argv.txHash, onRamp, argv)
   } else {
     const [getChain_, tx$] = fetchChainsFromRpcs(ctx, argv, argv.txHash)
     getChain = getChain_
     ;[source, tx] = await tx$
-    request = await selectRequest(await source.fetchRequestsInTx(tx), 'to know more', argv)
+    request = await selectRequest(await source.getMessagesInTx(tx), 'to know more', argv)
   }
 
   switch (argv.format) {
@@ -118,17 +120,16 @@ export async function showRequests(ctx: Ctx, argv: Parameters<typeof handler>[0]
   let cancelWaitFinalized: (() => void) | undefined
   const finalized$ = (async () => {
     if (argv.wait) {
-      logger.info('Waiting for finalization...')
-      await source.waitFinalized(
+      logger.info(`[${MessageStatus.Sent}] Waiting for source chain finalization...`)
+      await source.waitFinalized({
         request,
-        undefined,
-        new Promise<void>((resolve) => (cancelWaitFinalized = resolve)),
-      )
-      logger.info(`Transaction "${request.log.transactionHash}" finalized ✅`)
+        cancel$: new Promise<void>((resolve) => (cancelWaitFinalized = resolve)),
+      })
+      logger.info(`[${MessageStatus.SourceFinalized}] Source chain finalized`)
     }
 
-    const offchainTokenData = await source.fetchOffchainTokenData(request)
-    if (offchainTokenData?.length && offchainTokenData.some((d) => !!d)) {
+    const offchainTokenData = await source.getOffchainTokenData(request)
+    if (offchainTokenData.length && offchainTokenData.some((d) => !!d)) {
       switch (argv.format) {
         case Format.log: {
           logger.log('attestations =', offchainTokenData)
@@ -147,7 +148,8 @@ export async function showRequests(ctx: Ctx, argv: Parameters<typeof handler>[0]
       }
     }
 
-    if (argv.wait) logger.info('Waiting for Commit (dest)...')
+    if (argv.wait)
+      logger.info(`[${MessageStatus.SourceFinalized}] Waiting for commit on destination chain...`)
     else logger.info('Commit (dest):')
   })()
 
@@ -157,13 +159,16 @@ export async function showRequests(ctx: Ctx, argv: Parameters<typeof handler>[0]
 
   let cancelWaitCommit: (() => void) | undefined
   const commit$ = (async () => {
-    const commit = await dest.fetchCommitReport(commitStore, request, {
+    const commit = await dest.getCommitReport({
+      commitStore,
+      request,
       ...argv,
       watch: argv.wait && new Promise<void>((resolve) => (cancelWaitCommit = resolve)),
     })
     cancelWaitFinalized?.()
-    if (!commit) return
     await finalized$
+    if (argv.wait)
+      logger.info(`[${MessageStatus.Committed}] Commit report accepted on destination chain`)
     switch (argv.format) {
       case Format.log:
         logger.log('commit =', commit)
@@ -175,20 +180,33 @@ export async function showRequests(ctx: Ctx, argv: Parameters<typeof handler>[0]
         logger.info(JSON.stringify(commit, bigIntReplacer, 2))
         break
     }
-    if (argv.wait) logger.info('Waiting for Receipt (dest):')
+    if (argv.wait)
+      logger.info(`[${MessageStatus.Blessed}] Waiting for execution on destination chain...`)
     else logger.info('Receipts (dest):')
     return commit
   })()
 
   let found = false
-  for await (const receipt of dest.fetchExecutionReceipts(
+  for await (const receipt of dest.getExecutionReceipts({
+    ...argv,
     offRamp,
-    request,
-    !argv.wait ? await commit$ : undefined,
-    { ...argv, watch: argv.wait && ctx.destroy$ },
-  )) {
+    messageId: request.message.messageId,
+    sourceChainSelector: request.message.sourceChainSelector,
+    startTime: request.tx.timestamp,
+    commit: !argv.wait ? await commit$ : undefined,
+    watch: argv.wait && ctx.destroy$,
+  })) {
     cancelWaitCommit?.()
     await commit$
+    const status =
+      receipt.receipt.state === ExecutionState.Success
+        ? MessageStatus.Success
+        : MessageStatus.Failed
+    const statusMessage =
+      receipt.receipt.state === ExecutionState.Success
+        ? 'Message executed on destination chain'
+        : 'Message execution failed on destination chain'
+    logger.info(`[${status}] ${statusMessage}`)
     switch (argv.format) {
       case Format.log:
         logger.log('receipt =', withDateTimestamp(receipt))

package/src/commands/types.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '@chainlink/ccip-sdk/src/types.js'
+import type { Logger } from '@chainlink/ccip-sdk/src/index.ts'
 
 /** Output format options for CLI commands. */
 export const Format = {

package/src/commands/utils.ts

@@ -11,6 +11,7 @@ import {
   CCIPError,
   CCIPErrorCode,
   ExecutionState,
+  getCCIPExplorerUrl,
   networkInfo,
   supportedChains,
 } from '@chainlink/ccip-sdk/src/index.ts'
@@ -42,7 +43,7 @@ export async function selectRequest(
   hints?: { logIndex?: number },
 ): Promise<CCIPRequest> {
   if (hints?.logIndex != null) requests = requests.filter((req) => req.log.index === hints.logIndex)
-  if (requests.length === 1) return requests[0]
+  if (requests.length === 1) return requests[0]!
   const answer = await select({
     message: `${requests.length} messageIds found; select one${promptSuffix ? ' ' + promptSuffix : ''}`,
     choices: [
@@ -66,7 +67,7 @@ tokenTransfers =\t[${req.message.tokenAmounts.map((ta) => ('token' in ta ? ta.to
     ],
   })
   if (answer < 0) throw new CCIPError(CCIPErrorCode.UNKNOWN, 'User requested exit')
-  return requests[answer]
+  return requests[answer]!
 }
 
 /**
@@ -142,7 +143,7 @@ async function formatToken(
  * @returns Record with indexed keys.
  */
 export function formatArray<T>(name: string, values: readonly T[]): Record<string, T> {
-  if (values.length <= 1) return { [name]: values[0] }
+  if (values.length <= 1) return { [name]: values[0]! }
   return Object.fromEntries(values.map((v, i) => [`${name}[${i}]`, v] as const))
 }
 
@@ -296,6 +297,7 @@ export async function prettyRequest(this: Ctx, source: Chain, request: CCIPReque
     ...('accounts' in request.message ? formatArray('accounts', request.message.accounts) : {}),
     ...rest,
   })
+  this.logger.info('CCIP Explorer:', getCCIPExplorerUrl('msg', request.message.messageId))
 }
 
 /**
@@ -521,7 +523,7 @@ export function logParsedError(this: Ctx, err: unknown): boolean {
 export async function parseTokenAmounts(source: Chain, transferTokens: readonly string[]) {
   return Promise.all(
     transferTokens.map(async (tokenAmount) => {
-      const [token, amount_] = tokenAmount.split('=')
+      const [token, amount_] = tokenAmount.split('=') as [string, string]
       const { decimals } = await source.getTokenInfo(token)
       const amount = parseUnits(amount_, decimals)
       return { token, amount }

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.92.0-bbb73be'
+const VERSION = '0.93.0-e6b317b'
 // generate:end
 
 const globalOpts = {
@@ -41,7 +41,11 @@ const globalOpts = {
   page: {
     type: 'number',
     describe: 'getLogs page/range size',
-    default: 10_000,
+  },
+  'no-api': {
+    type: 'boolean',
+    describe: 'Disable CCIP API integration (full decentralization mode)',
+    default: false,
   },
 } as const
 
@@ -66,12 +70,12 @@ async function main() {
 }
 
 function wasCalledAsScript() {
-  const realPath = realpathSync(process.argv[1])
+  const realPath = realpathSync(process.argv[1]!)
   const realPathAsUrl = pathToFileURL(realPath).href
   return import.meta.url === realPathAsUrl
 }
 
-if (import.meta?.main || wasCalledAsScript()) {
+if (import.meta.main || wasCalledAsScript()) {
   const later = setTimeout(() => {}, 2 ** 31 - 1) // keep event-loop alive
   await main()
     .catch((err) => {

package/src/providers/aptos.ts

@@ -99,7 +99,7 @@ export class AptosLedgerSigner /*implements AptosAsyncAccount*/ {
  */
 export async function loadAptosWallet({ wallet: walletOpt }: { wallet?: unknown }) {
   if (typeof walletOpt !== 'string') throw new CCIPArgumentInvalidError('wallet', String(walletOpt))
-  if ((walletOpt ?? '').startsWith('ledger')) {
+  if (walletOpt.startsWith('ledger')) {
     let derivationPath = walletOpt.split(':')[1]
     if (!derivationPath) derivationPath = "m/44'/637'/0'/0'/0'"
     else if (!isNaN(Number(derivationPath))) derivationPath = `m/44'/637'/${derivationPath}'/0'/0'`

package/src/providers/evm.ts

@@ -43,7 +43,7 @@ export async function loadEvmWallet(
     )
   }
   if (typeof walletOpt !== 'string') throw new CCIPArgumentInvalidError('wallet', String(walletOpt))
-  if ((walletOpt ?? '').startsWith('ledger')) {
+  if (walletOpt.startsWith('ledger')) {
     let derivationPath = walletOpt.split(':')[1]
     if (derivationPath && !isNaN(Number(derivationPath)))
       derivationPath = `m/44'/60'/${derivationPath}'/0/0`

package/src/providers/index.ts

@@ -6,6 +6,7 @@ import {
   type ChainGetter,
   type ChainTransaction,
   type EVMChain,
+  type TONChain,
   CCIPChainFamilyUnsupportedError,
   CCIPNetworkFamilyUnsupportedError,
   CCIPRpcNotFoundError,
@@ -53,11 +54,11 @@ async function collectEndpoints(
 
 export function fetchChainsFromRpcs(
   ctx: Ctx,
-  argv: { rpcs?: string[]; rpcsFile?: string },
+  argv: { rpcs?: string[]; rpcsFile?: string; noApi?: boolean },
 ): ChainGetter
 export function fetchChainsFromRpcs(
   ctx: Ctx,
-  argv: { rpcs?: string[]; rpcsFile?: string },
+  argv: { rpcs?: string[]; rpcsFile?: string; noApi?: boolean },
   txHash: string,
 ): [ChainGetter, Promise<[Chain, ChainTransaction]>]
 
@@ -66,13 +67,13 @@ export function fetchChainsFromRpcs(
  * If txHash is provided, fetches matching families first and returns [chainGetter, txPromise];
  * Otherwise, spawns racing URLs for each family asked by `getChain` getter
  * @param ctx - Context object containing destroy$ promise and logger properties
- * @param argv - Options containing rpcs (list) and/or rpcs file
+ * @param argv - Options containing rpcs (list), rpcs file and noApi flag
  * @param txHash - Optional txHash to fetch concurrently; causes the function to return a [ChainGetter, Promise<ChainTransaction>]
  * @returns a ChainGetter (if txHash was provided), or a tuple of [ChainGetter, Promise<ChainTransaction>]
  */
 export function fetchChainsFromRpcs(
   ctx: Ctx,
-  argv: { rpcs?: string[]; rpcsFile?: string },
+  argv: { rpcs?: string[]; rpcsFile?: string; noApi?: boolean },
   txHash?: string,
 ) {
   const chains: Record<string, Promise<Chain>> = {}
@@ -82,7 +83,7 @@ export function fetchChainsFromRpcs(
   > = {}
   const finished: Partial<Record<ChainFamily, boolean>> = {}
   const initFamily$: Partial<Record<ChainFamily, Promise<unknown>>> = {}
-  let endpoints$: Promise<Set<string>>
+  let endpoints$: Promise<Set<string>> | undefined
 
   let txResolve: (value: [Chain, ChainTransaction]) => void, txReject: (reason?: unknown) => void
   const txResult = new Promise<[Chain, ChainTransaction]>((resolve, reject) => {
@@ -100,7 +101,10 @@ export function fetchChainsFromRpcs(
       const txs$: Promise<unknown>[] = []
       let txFound = false
       for (const url of endpoints) {
-        const chain$ = C.fromUrl(url, ctx)
+        const chain$ = C.fromUrl(url, {
+          ...ctx,
+          apiClient: argv.noApi ? null : undefined,
+        })
         chains$.push(chain$)
 
         void chain$.then(
@@ -116,7 +120,7 @@ export function fetchChainsFromRpcs(
               chains[chain.network.name] = Promise.resolve(chain)
             } else if (chain.network.name in chainsCbs) {
               // chain detected, and there's a "pending request" by getChain: resolve
-              const [resolve] = chainsCbs[chain.network.name]
+              const [resolve] = chainsCbs[chain.network.name]!
               resolve(chain)
             }
             return chain
@@ -152,16 +156,16 @@ export function fetchChainsFromRpcs(
 
   const chainGetter = async (idOrSelectorOrName: number | string | bigint): Promise<Chain> => {
     const network = networkInfo(idOrSelectorOrName)
-    if (network.name in chains) return chains[network.name]
+    if (network.name in chains) return chains[network.name]!
     if (finished[network.family]) throw new CCIPRpcNotFoundError(network.name)
-    chains[network.name] = new Promise((resolve, reject) => {
+    const c = (chains[network.name] = new Promise((resolve, reject) => {
       chainsCbs[network.name] = [resolve, reject]
-    })
-    void chains[network.name].finally(() => {
+    }))
+    void c.finally(() => {
       delete chainsCbs[network.name] // when chain is settled, delete the callbacks
     })
     void loadChainFamily(network.family)
-    return chains[network.name]
+    return c
   }
 
   if (!txHash) return chainGetter
@@ -210,8 +214,8 @@ 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(argv)
-      return [wallet.contract.address.toString(), wallet] as const
+      wallet = await loadTonWallet((chain as TONChain).provider, argv, chain.network.isTestnet)
+      return [wallet.getAddress(), wallet] as const
     default:
       // TypeScript exhaustiveness check - this should never be reached
       throw new CCIPChainFamilyUnsupportedError((chain.network as { family: string }).family)

package/src/providers/sui.ts

@@ -1,5 +1,4 @@
-import { CCIPArgumentInvalidError } from '@chainlink/ccip-sdk/src/index.ts'
-import { bytesToBuffer } from '@chainlink/ccip-sdk/src/utils.ts'
+import { CCIPArgumentInvalidError, bytesToBuffer } from '@chainlink/ccip-sdk/src/index.ts'
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519'
 
 /**

package/src/providers/ton.ts

@@ -1,36 +1,106 @@
 import { existsSync, readFileSync } from 'node:fs'
 
 import {
+  type UnsignedTONTx,
   CCIPArgumentInvalidError,
   CCIPWalletInvalidError,
-} from '@chainlink/ccip-sdk/src/errors/specialized.ts'
-import type { TONWallet } from '@chainlink/ccip-sdk/src/ton/types.ts'
+  bytesToBuffer,
+} from '@chainlink/ccip-sdk/src/index.ts'
+import HIDTransport from '@ledgerhq/hw-transport-node-hid'
 import { keyPairFromSecretKey, mnemonicToPrivateKey } from '@ton/crypto'
-import { WalletContractV4 } from '@ton/ton'
+import { type TonClient, Address, SendMode, WalletContractV4, internal, toNano } from '@ton/ton'
+import { TonTransport } from '@ton-community/ton-ledger'
 
 /**
  * Loads a TON wallet from the provided options.
+ * @param client - TON client instance
  * @param wallet - wallet options (as passed from yargs argv)
+ * @param isTestnet - whether the wallet is on the testnet
  * @returns Promise to TONWallet instance
  */
-export async function loadTonWallet({
-  wallet: walletOpt,
-}: { wallet?: unknown } = {}): Promise<TONWallet> {
+export async function loadTonWallet(
+  client: TonClient,
+  { wallet: walletOpt }: { wallet?: unknown } = {},
+  isTestnet?: boolean,
+) {
   if (typeof walletOpt !== 'string') throw new CCIPWalletInvalidError(walletOpt)
-
-  // Handle mnemonic phrase
-  if (walletOpt.includes(' ')) {
-    const mnemonic = walletOpt.trim().split(' ')
-    const keyPair = await mnemonicToPrivateKey(mnemonic)
+  if (walletOpt === 'ledger' || walletOpt.startsWith('ledger:')) {
+    const transport = await HIDTransport.default.create()
+    const ton = new TonTransport(transport)
+    let derivationPath = walletOpt.split(':')[1]
+    if (!derivationPath) derivationPath = `44'/607'/${isTestnet ? '1' : '0'}'/0/0/0`
+    else if (!isNaN(Number(derivationPath)))
+      derivationPath = `44'/607'/${isTestnet ? '1' : '0'}'/0/${derivationPath}/0`
+    const match = derivationPath.match(
+      /^(?:m\/)?(\d+)'?\/(\d+)'?\/(\d+)'?\/(\d+)'?\/(\d+)'?\/(\d+)'?$/,
+    )
+    if (!match) throw new CCIPWalletInvalidError(walletOpt)
+    const path = match.slice(1).map((x) => parseInt(x))
+    const { address, publicKey } = await ton.getAddress(path, {
+      chain: 0,
+      bounceable: false,
+      testOnly: isTestnet,
+    })
+    console.info('Ledger TON:', address, ', derivationPath:', derivationPath)
     const contract = WalletContractV4.create({
       workchain: 0,
-      publicKey: keyPair.publicKey,
+      publicKey,
     })
-    return { contract, keyPair }
+    const openedWallet = client.open(contract)
+    return {
+      getAddress: () => address,
+      sendTransaction: async ({ value, body, ...args }: UnsignedTONTx) => {
+        const seqno = await openedWallet.getSeqno()
+        const to = Address.parse(args.to)
+        if (!value) {
+          const { source_fees } = await client.estimateExternalMessageFee(to, {
+            ignoreSignature: true,
+            body,
+            initCode: null,
+            initData: null,
+          })
+          value =
+            BigInt(
+              source_fees.storage_fee +
+                source_fees.gas_fee +
+                source_fees.fwd_fee +
+                source_fees.in_fwd_fee,
+            ) + toNano('0.0001') // buffer
+        }
+        const signed = await ton.signTransaction(path, {
+          seqno,
+          amount: value,
+          sendMode: SendMode.IGNORE_ERRORS | SendMode.PAY_GAS_SEPARATELY,
+          timeout: Math.floor(Date.now() / 1000 + 60),
+          bounce: false,
+          ...args,
+          to,
+          payload: {
+            type: 'unsafe',
+            message: body,
+          },
+        })
+        await openedWallet.send(signed)
+        return seqno
+      },
+    }
   }
 
-  // Handle hex private key
-  if (walletOpt.startsWith('0x')) {
+  let keyPair
+  if (existsSync(walletOpt)) {
+    // Handle file path
+    const content = readFileSync(walletOpt, 'utf8').trim()
+    const secretKey = bytesToBuffer(content)
+    if (secretKey.length !== 64) {
+      throw new CCIPArgumentInvalidError('wallet', 'Invalid private key in file: must be 64 bytes')
+    }
+    keyPair = keyPairFromSecretKey(secretKey)
+  } else if (walletOpt.includes(' ')) {
+    // Handle mnemonic phrase
+    const mnemonic = walletOpt.trim().split(' ')
+    keyPair = await mnemonicToPrivateKey(mnemonic)
+  } else if (walletOpt.startsWith('0x')) {
+    // Handle hex private key
     const secretKey = Buffer.from(walletOpt.slice(2), 'hex')
     if (secretKey.length === 32) {
       throw new CCIPArgumentInvalidError(
@@ -41,27 +111,33 @@ export async function loadTonWallet({
     if (secretKey.length !== 64) {
       throw new CCIPArgumentInvalidError('wallet', 'must be 64 bytes (or use mnemonic)')
     }
-    const keyPair = keyPairFromSecretKey(secretKey)
-    const contract = WalletContractV4.create({
-      workchain: 0,
-      publicKey: keyPair.publicKey,
-    })
-    return { contract, keyPair }
+    keyPair = keyPairFromSecretKey(secretKey)
   }
 
-  // Handle file path
-  if (existsSync(walletOpt)) {
-    const content = readFileSync(walletOpt, 'utf8').trim()
-    const secretKey = Buffer.from(content.startsWith('0x') ? content.slice(2) : content, 'hex')
-    if (secretKey.length !== 64) {
-      throw new CCIPArgumentInvalidError('wallet', 'Invalid private key in file: must be 64 bytes')
-    }
-    const keyPair = keyPairFromSecretKey(secretKey)
+  if (keyPair) {
     const contract = WalletContractV4.create({
       workchain: 0,
       publicKey: keyPair.publicKey,
     })
-    return { contract, keyPair }
+    const openedWallet = client.open(contract)
+    return {
+      getAddress: () => contract.address.toString(),
+      sendTransaction: async (args: UnsignedTONTx) => {
+        const seqno = await openedWallet.getSeqno()
+        const signed = await openedWallet.createTransfer({
+          ...keyPair,
+          seqno,
+          messages: [
+            internal({
+              value: toNano('0.3'), // TODO: FIXME: estimate proper value for execution costs instead of hardcoding.
+              ...args,
+            }),
+          ],
+        })
+        await openedWallet.send(signed)
+        return seqno
+      },
+    }
   }
 
   throw new CCIPArgumentInvalidError('wallet', 'Wallet not specified')

package/tsconfig.json

@@ -14,6 +14,7 @@
     "verbatimModuleSyntax": true,
     "erasableSyntaxOnly": true,
     "resolveJsonModule": true,
-    "noImplicitOverride": true
-  }
+    "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": true,
+  },
 }