@chainlink/ccip-cli 0.91.0 → 0.92.0

package/src/providers/index.ts

@@ -1,3 +1,4 @@
+import { existsSync, readFileSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 
 import {
@@ -5,6 +6,10 @@ import {
   type ChainGetter,
   type ChainTransaction,
   type EVMChain,
+  CCIPChainFamilyUnsupportedError,
+  CCIPNetworkFamilyUnsupportedError,
+  CCIPRpcNotFoundError,
+  CCIPTransactionNotFoundError,
   ChainFamily,
   networkInfo,
   supportedChains,
@@ -13,46 +18,26 @@ import {
 import { loadAptosWallet } from './aptos.ts'
 import { loadEvmWallet } from './evm.ts'
 import { loadSolanaWallet } from './solana.ts'
+import { loadSuiWallet } from './sui.ts'
+import { loadTonWallet } from './ton.ts'
 import type { Ctx } from '../commands/index.ts'
 
 const RPCS_RE = /\b(?:http|ws)s?:\/\/[\w/\\@&?%~#.,;:=+-]+/
 
-const signalToPromiseMap = new WeakMap<AbortSignal, Promise<void>>()
-function signalToPromise(signal: AbortSignal) {
-  let promise = signalToPromiseMap.get(signal)
-  if (!promise) {
-    signalToPromiseMap.set(
-      signal,
-      (promise = new Promise((_, reject) => {
-        signal.throwIfAborted()
-        signal.addEventListener(
-          'abort',
-          () =>
-            reject(
-              signal.reason instanceof Error
-                ? signal.reason
-                : new Error(`Aborted: ${signal.reason as string}`),
-            ),
-          { once: true },
-        )
-      })),
-    )
-  }
-  return promise
-}
-
-async function collectEndpoints({
-  rpcs,
-  'rpcs-file': rpcsFile,
-}: {
-  rpcs?: string[]
-  'rpcs-file'?: string
-}): Promise<Set<string>> {
-  const endpoints = new Set<string>(rpcs || [])
+async function collectEndpoints(
+  this: Ctx,
+  { rpcs, rpcsFile }: { rpcs?: string[]; rpcsFile?: string },
+): Promise<Set<string>> {
+  const endpoints = new Set<string>(
+    rpcs
+      ?.map((s) => s.split(','))
+      .flat()
+      .map((s) => s.trim()) || [],
+  )
   for (const [env, val] of Object.entries(process.env)) {
     if (env.startsWith('RPC_') && val && RPCS_RE.test(val)) endpoints.add(val)
   }
-  if (rpcsFile) {
+  if (rpcsFile && existsSync(rpcsFile)) {
     try {
       const fileContent = await readFile(rpcsFile, 'utf8')
       for (const line of fileContent.toString().split(/(?:\r\n|\r|\n)/g)) {
@@ -60,7 +45,7 @@ async function collectEndpoints({
         if (match) endpoints.add(match[0])
       }
     } catch (error) {
-      console.debug('Error reading RPCs file', error)
+      this.logger.debug('Error reading RPCs file', error)
     }
   }
   return endpoints
@@ -68,126 +53,167 @@ async function collectEndpoints({
 
 export function fetchChainsFromRpcs(
   ctx: Ctx,
-  argv: { rpcs?: string[]; 'rpcs-file'?: string },
+  argv: { rpcs?: string[]; rpcsFile?: string },
 ): ChainGetter
 export function fetchChainsFromRpcs(
   ctx: Ctx,
-  argv: { rpcs?: string[]; 'rpcs-file'?: string },
+  argv: { rpcs?: string[]; rpcsFile?: string },
   txHash: string,
 ): [ChainGetter, Promise<[Chain, ChainTransaction]>]
 
 /**
- * Receives a list of rpcs and/or rpcs file, and loads them all concurrently
- * Returns a ChainGetter function and optinoally a ChainTransaction promise
+ * Receives a list of rpcs and/or rpcs file, and loads them concurrently for each chain family
+ * 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 txHash - Optional txHash to fetch concurrently; causes the function to return a [ChainGetter, Promise<ChainTransaction>]
- * @returns a ChainGetter (alone if no txHash was provided), or a tuple of [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[]; 'rpcs-file'?: string },
+  argv: { rpcs?: string[]; rpcsFile?: string },
   txHash?: string,
 ) {
-  const { destroy$ } = ctx
   const chains: Record<string, Promise<Chain>> = {}
   const chainsCbs: Record<
     string,
     readonly [resolve: (value: Chain) => void, reject: (reason?: unknown) => void]
   > = {}
-  let finished = false
-  const txs: Promise<[Chain, ChainTransaction]>[] = []
+  const finished: Partial<Record<ChainFamily, boolean>> = {}
+  const initFamily$: Partial<Record<ChainFamily, Promise<unknown>>> = {}
+  let endpoints$: Promise<Set<string>>
+
+  let txResolve: (value: [Chain, ChainTransaction]) => void, txReject: (reason?: unknown) => void
+  const txResult = new Promise<[Chain, ChainTransaction]>((resolve, reject) => {
+    txResolve = resolve
+    txReject = reject
+  })
+
+  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)
+      ctx.logger.debug('Racing', endpoints.size, 'RPC endpoints for', F)
 
-  const init$ = collectEndpoints(argv).then((endpoints) => {
-    const pendingPromises: Promise<unknown>[] = []
-    let txFound = false
-    for (const C of Object.values(supportedChains)) {
+      const chains$: Promise<Chain>[] = []
+      const txs$: Promise<unknown>[] = []
+      let txFound = false
       for (const url of endpoints) {
         const chain$ = C.fromUrl(url, ctx)
-        if (txHash) {
-          const tx$ = chain$.then((chain) =>
-            chain.getTransaction(txHash).then<[Chain, ChainTransaction]>((tx) => [chain, tx]),
-          )
-          void tx$.then(
-            ([chain]) => {
-              if (txFound) return
-              txFound = true
-              // in case tx is found, prefer it over any previously found chain
-              chains[chain.network.name] = chain$
-              delete chainsCbs[chain.network.name]
-            },
-            () => {},
-          )
-          txs.push(tx$)
-        }
+        chains$.push(chain$)
 
-        pendingPromises.push(
-          chain$.then((chain) => {
+        void chain$.then(
+          (chain) => {
+            endpoints.delete(url) // when resolved, remove from set so it isn't tried for future families
+            // on chain detected for url
             if (chain.network.name in chains && !(chain.network.name in chainsCbs))
-              return chain.destroy?.() // lost race
-            destroy$.addEventListener('abort', () => {
-              void chain.destroy?.() // cleanup
-            })
+              return chain.destroy?.() // but lost race, cleanup right away
+            // keep and schedule cleanup on shutdown
+            if (chain.destroy) void ctx.destroy$.finally(chain.destroy.bind(chain))
             if (!(chain.network.name in chains)) {
+              // chain won for this network, but was not "asked" by getChain (yet?): save
               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]
               resolve(chain)
             }
-          }),
+            return chain
+          },
+          () => {},
         )
+
+        if (txHash) {
+          txs$.push(
+            chain$.then(async (chain) => {
+              const tx = await chain.getTransaction(txHash)
+              if (!txFound) {
+                txFound = true
+                // in case tx is first found, prefer it over any previously found chain for this network
+                chains[chain.network.name] = chain$
+                delete chainsCbs[chain.network.name]
+              }
+              txResolve([chain, tx])
+            }),
+          )
+        }
       }
-    }
-    const res = Promise.allSettled(pendingPromises)
-    void (destroy$ ? Promise.race([res, signalToPromise(destroy$)]) : res).finally(() => {
-      finished = true
-      Object.entries(chainsCbs).forEach(([name, [_, reject]]) =>
-        reject(new Error(`No provider/chain found for network=${name}`)),
-      )
-    })
-    return Promise.any(txs)
-  })
+
+      void Promise.race([Promise.allSettled(chains$), ctx.destroy$]).finally(() => {
+        if (finished[F]) return
+        finished[F] = true
+        Object.entries(chainsCbs)
+          .filter(([name]) => networkInfo(name).family === F)
+          .forEach(([name, [_, reject]]) => reject(new CCIPRpcNotFoundError(name)))
+      })
+      return Promise.any(txHash ? txs$ : chains$)
+    }))
 
   const chainGetter = async (idOrSelectorOrName: number | string | bigint): Promise<Chain> => {
     const network = networkInfo(idOrSelectorOrName)
     if (network.name in chains) return chains[network.name]
-    if (finished) throw new Error(`No provider/chain found for network=${network.name}`)
+    if (finished[network.family]) throw new CCIPRpcNotFoundError(network.name)
     chains[network.name] = new Promise((resolve, reject) => {
       chainsCbs[network.name] = [resolve, reject]
     })
     void chains[network.name].finally(() => {
-      delete chainsCbs[network.name]
+      delete chainsCbs[network.name] // when chain is settled, delete the callbacks
     })
+    void loadChainFamily(network.family)
     return chains[network.name]
   }
 
-  if (txHash) {
-    return [chainGetter, init$]
-  } else {
-    void init$.catch(() => {})
-    return chainGetter
-  }
+  if (!txHash) return chainGetter
+
+  void Promise.allSettled(
+    Object.values(supportedChains)
+      .filter((C) => C.isTxHash(txHash))
+      .map((C) => loadChainFamily(C.family, txHash)),
+  ).finally(() => txReject(new CCIPTransactionNotFoundError(txHash))) // noop if txResolved
+  return [chainGetter, txResult]
 }
 
 /**
  * Load chain-specific wallet for given chain
  * @param chain - Chain instance to load wallet for
- * @param opts - Wallet options (as passed from yargs argv)
+ * @param argv - Wallet options (as passed from yargs argv)
  * @returns Promise to chain-specific wallet instance
  */
-export async function loadChainWallet(chain: Chain, opts: { wallet?: unknown }) {
+export async function loadChainWallet(chain: Chain, argv: { wallet?: unknown; rpcsFile?: string }) {
+  // Centralized wallet resolution: check env vars first, then rpcsFile
+  if (!argv.wallet) {
+    argv.wallet = process.env['PRIVATE_KEY'] || process.env['USER_KEY'] || process.env['OWNER_KEY']
+  }
+  if (!argv.wallet && argv.rpcsFile && existsSync(argv.rpcsFile)) {
+    try {
+      const file = readFileSync(argv.rpcsFile, 'utf8')
+      const match = file.match(/^\s*(PRIVATE_KEY|USER_KEY|OWNER_KEY)=(\S+)/m)
+      if (match) argv.wallet = match[2]
+    } catch (_) {
+      // pass
+    }
+  }
+
   let wallet
   switch (chain.network.family) {
     case ChainFamily.EVM:
-      wallet = await loadEvmWallet((chain as EVMChain).provider, opts)
+      wallet = await loadEvmWallet((chain as EVMChain).provider, argv)
       return [await wallet.getAddress(), wallet] as const
     case ChainFamily.Solana:
-      wallet = await loadSolanaWallet(opts)
+      wallet = await loadSolanaWallet(argv)
       return [wallet.publicKey.toBase58(), wallet] as const
     case ChainFamily.Aptos:
-      wallet = await loadAptosWallet(opts)
+      wallet = await loadAptosWallet(argv)
       return [wallet.accountAddress.toString(), wallet] as const
+    case ChainFamily.Sui:
+      wallet = loadSuiWallet(argv)
+      return [wallet.toSuiAddress(), wallet] as const
+    case ChainFamily.TON:
+      wallet = await loadTonWallet(argv)
+      return [wallet.contract.address.toString(), wallet] as const
     default:
-      throw new Error(`Unsupported chain family: ${chain.network.family}`)
+      // TypeScript exhaustiveness check - this should never be reached
+      throw new CCIPChainFamilyUnsupportedError((chain.network as { family: string }).family)
   }
 }

package/src/providers/solana.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs'
-import util from 'node:util'
 
+import { CCIPArgumentInvalidError, CCIPNotImplementedError } from '@chainlink/ccip-sdk/src/index.ts'
 import { Wallet as AnchorWallet } from '@coral-xyz/anchor'
 import SolanaLedger from '@ledgerhq/hw-app-solana'
 import HIDTransport from '@ledgerhq/hw-transport-node-hid'
@@ -86,7 +86,7 @@ export class LedgerSolanaWallet {
 
   /** Payer property - not available on Ledger. */
   get payer(): Keypair {
-    throw new Error('Payer method not available on Ledger')
+    throw new CCIPNotImplementedError('payer for Ledger')
   }
 }
 
@@ -98,11 +98,10 @@ export class LedgerSolanaWallet {
 export async function loadSolanaWallet({
   wallet: walletOpt,
 }: { wallet?: unknown } = {}): Promise<AnchorWallet> {
-  if (!walletOpt)
-    walletOpt = process.env['USER_KEY'] || process.env['OWNER_KEY'] || '~/.config/solana/id.json'
+  // Default to Solana's standard keypair location if no wallet provided
+  if (!walletOpt) walletOpt = '~/.config/solana/id.json'
   let wallet: string
-  if (typeof walletOpt !== 'string')
-    throw new Error(`Invalid wallet option: ${util.inspect(walletOpt)}`)
+  if (typeof walletOpt !== 'string') throw new CCIPArgumentInvalidError('wallet', String(walletOpt))
   wallet = walletOpt
   if (walletOpt === 'ledger' || walletOpt.startsWith('ledger:')) {
     let derivationPath = walletOpt.split(':')[1]

package/src/providers/sui.ts

@@ -0,0 +1,15 @@
+import { CCIPArgumentInvalidError } from '@chainlink/ccip-sdk/src/index.ts'
+import { bytesToBuffer } from '@chainlink/ccip-sdk/src/utils.ts'
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519'
+
+/**
+ * Loads a Sui wallet from the provided options.
+ * @param wallet - wallet options (as passed from yargs argv)
+ * @returns Sui Keypair instance
+ */
+export function loadSuiWallet({ wallet: walletOpt }: { wallet?: unknown }) {
+  if (typeof walletOpt !== 'string') throw new CCIPArgumentInvalidError('wallet', String(walletOpt))
+
+  const keyBytes = bytesToBuffer(walletOpt)
+  return Ed25519Keypair.fromSecretKey(keyBytes)
+}

package/src/providers/ton.ts

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync } from 'node:fs'
+
+import {
+  CCIPArgumentInvalidError,
+  CCIPWalletInvalidError,
+} from '@chainlink/ccip-sdk/src/errors/specialized.ts'
+import type { TONWallet } from '@chainlink/ccip-sdk/src/ton/types.ts'
+import { keyPairFromSecretKey, mnemonicToPrivateKey } from '@ton/crypto'
+import { WalletContractV4 } from '@ton/ton'
+
+/**
+ * Loads a TON wallet from the provided options.
+ * @param wallet - wallet options (as passed from yargs argv)
+ * @returns Promise to TONWallet instance
+ */
+export async function loadTonWallet({
+  wallet: walletOpt,
+}: { wallet?: unknown } = {}): Promise<TONWallet> {
+  if (typeof walletOpt !== 'string') throw new CCIPWalletInvalidError(walletOpt)
+
+  // Handle mnemonic phrase
+  if (walletOpt.includes(' ')) {
+    const mnemonic = walletOpt.trim().split(' ')
+    const keyPair = await mnemonicToPrivateKey(mnemonic)
+    const contract = WalletContractV4.create({
+      workchain: 0,
+      publicKey: keyPair.publicKey,
+    })
+    return { contract, keyPair }
+  }
+
+  // Handle hex private key
+  if (walletOpt.startsWith('0x')) {
+    const secretKey = Buffer.from(walletOpt.slice(2), 'hex')
+    if (secretKey.length === 32) {
+      throw new CCIPArgumentInvalidError(
+        'wallet',
+        '32-byte seeds not supported. Use 64-byte secret key or mnemonic.',
+      )
+    }
+    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 }
+  }
+
+  // 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)
+    const contract = WalletContractV4.create({
+      workchain: 0,
+      publicKey: keyPair.publicKey,
+    })
+    return { contract, keyPair }
+  }
+
+  throw new CCIPArgumentInvalidError('wallet', 'Wallet not specified')
+}