@chainlink/ccip-cli 0.0.0 → 0.90.0

package/src/providers/index.ts

@@ -0,0 +1,141 @@
+import { readFile } from 'node:fs/promises'
+
+import {
+  type Chain,
+  type ChainGetter,
+  type ChainTransaction,
+  networkInfo,
+  supportedChains,
+} from '@chainlink/ccip-sdk/src/index.ts'
+
+import './aptos.ts'
+import './evm.ts'
+import './solana.ts'
+
+const RPCS_RE = /\b(?:http|ws)s?:\/\/[\w/\\@&?%~#.,;:=+-]+/
+
+async function collectEndpoints({
+  rpcs,
+  'rpcs-file': rpcsFile,
+}: {
+  rpcs?: string[]
+  'rpcs-file'?: string
+}): Promise<Set<string>> {
+  const endpoints = new Set<string>(rpcs || [])
+  for (const [env, val] of Object.entries(process.env)) {
+    if (env.startsWith('RPC_') && val && RPCS_RE.test(val)) endpoints.add(val)
+  }
+  if (rpcsFile) {
+    try {
+      const fileContent = await readFile(rpcsFile, 'utf8')
+      for (const line of fileContent.toString().split(/(?:\r\n|\r|\n)/g)) {
+        const match = line.match(RPCS_RE)
+        if (match) endpoints.add(match[0])
+      }
+    } catch (error) {
+      console.debug('Error reading RPCs file', error)
+    }
+  }
+  return endpoints
+}
+
+export function fetchChainsFromRpcs(
+  argv: { rpcs?: string[]; 'rpcs-file'?: string },
+  txHash?: undefined,
+  destroy?: Promise<unknown>,
+): ChainGetter
+export function fetchChainsFromRpcs(
+  argv: { rpcs?: string[]; 'rpcs-file'?: string },
+  txHash: string,
+  destroy?: Promise<unknown>,
+): [ChainGetter, Promise<ChainTransaction>]
+
+/**
+ * Receives a list of rpcs and/or rpcs file, and loads them all concurrently
+ * Returns a ChainGetter function and optinoally a ChainTransaction promise
+ * @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>]
+ * @param destroy - A promise to signal when to stop fetching chains
+ * @returns a ChainGetter (alone if no txHash was provided), or a tuple of [ChainGetter, Promise<ChainTransaction>]
+ */
+export function fetchChainsFromRpcs(
+  argv: { rpcs?: string[]; 'rpcs-file'?: string },
+  txHash?: string,
+  destroy?: Promise<unknown>,
+) {
+  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<ChainTransaction>[] = []
+
+  const init$ = collectEndpoints(argv).then((endpoints) => {
+    const pendingPromises: Promise<unknown>[] = []
+    let txFound = false
+    for (const C of Object.values(supportedChains)) {
+      for (const url of endpoints) {
+        const chain$ = C.fromUrl(url)
+        if (txHash) {
+          const tx$ = chain$.then((chain) => chain.getTransaction(txHash))
+          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$)
+        }
+
+        pendingPromises.push(
+          chain$.then((chain) => {
+            if (chain.network.name in chains && !(chain.network.name in chainsCbs))
+              return chain.destroy?.() // lost race
+            void destroy?.finally(() => {
+              void chain.destroy?.() // cleanup
+            })
+            if (!(chain.network.name in chains)) {
+              chains[chain.network.name] = Promise.resolve(chain)
+            } else if (chain.network.name in chainsCbs) {
+              const [resolve] = chainsCbs[chain.network.name]
+              resolve(chain)
+            }
+          }),
+        )
+      }
+    }
+    const res = Promise.allSettled(pendingPromises)
+    void (destroy ? Promise.race([res, 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)
+  })
+
+  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}`)
+    chains[network.name] = new Promise((resolve, reject) => {
+      chainsCbs[network.name] = [resolve, reject]
+    })
+    void chains[network.name].finally(() => {
+      delete chainsCbs[network.name]
+    })
+    return chains[network.name]
+  }
+
+  if (txHash) {
+    return [chainGetter, init$]
+  } else {
+    void init$.catch(() => {})
+    return chainGetter
+  }
+}

package/src/providers/solana.ts

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync } from 'node:fs'
+import util from 'node:util'
+
+import { SolanaChain } from '@chainlink/ccip-sdk/src/index.ts'
+import { Wallet as SolanaWallet } from '@coral-xyz/anchor'
+import SolanaLedger from '@ledgerhq/hw-app-solana'
+import HIDTransport from '@ledgerhq/hw-transport-node-hid'
+import {
+  type Message,
+  type MessageV0,
+  type VersionedTransaction,
+  Keypair,
+  PublicKey,
+  Transaction,
+} from '@solana/web3.js'
+import bs58 from 'bs58'
+import { getBytes, hexlify } from 'ethers'
+
+export class LedgerSolanaWallet {
+  publicKey: PublicKey
+  wallet: SolanaLedger.default
+  path: string
+
+  private constructor(solanaLW: SolanaLedger.default, pubKey: PublicKey, path: string) {
+    this.wallet = solanaLW
+    this.publicKey = pubKey
+    this.path = path
+  }
+
+  static async create(path: string) {
+    try {
+      const transport = await HIDTransport.default.create()
+      const solana = new SolanaLedger.default(transport)
+      const { address } = await solana.getAddress(path, false)
+      const pubkey = new PublicKey(address)
+      console.info('Ledger connected:', pubkey.toBase58(), `, derivationPath:`, path)
+      return new LedgerSolanaWallet(solana, pubkey, path)
+    } catch (e) {
+      console.error('Ledger: Could not access ledger. Is it unlocked and Solana app open?')
+      throw e
+    }
+  }
+
+  async signTransaction<T extends Transaction | VersionedTransaction>(tx: T) {
+    console.debug('Ledger: Request to sign message from', this.publicKey.toBase58())
+    // serializeMessage on v0, serialize on v1
+
+    let msg: Message | MessageV0
+    if (tx instanceof Transaction) {
+      msg = tx.compileMessage()
+    } else {
+      msg = tx.message
+    }
+    const { signature } = await this.wallet.signTransaction(this.path, Buffer.from(msg.serialize()))
+    tx.addSignature(this.publicKey, signature)
+    return tx
+  }
+
+  async signAllTransactions<T extends Transaction | VersionedTransaction>(txs: T[]) {
+    console.info('Signing multiple transactions with Ledger')
+    const signedTxs: T[] = []
+    for (const tx of txs) {
+      signedTxs.push(await this.signTransaction(tx))
+    }
+    return signedTxs
+  }
+
+  get payer(): Keypair {
+    throw new Error('Payer method not available on Ledger')
+  }
+}
+
+SolanaChain.getWallet = async function loadSolanaWallet({
+  wallet: walletOpt,
+}: { wallet?: unknown } = {}): Promise<SolanaWallet> {
+  if (!walletOpt)
+    walletOpt = process.env['USER_KEY'] || process.env['OWNER_KEY'] || '~/.config/solana/id.json'
+  let wallet: string
+  if (typeof walletOpt !== 'string')
+    throw new Error(`Invalid wallet option: ${util.inspect(walletOpt)}`)
+  wallet = walletOpt
+  if (walletOpt === 'ledger' || walletOpt.startsWith('ledger:')) {
+    let derivationPath = walletOpt.split(':')[1]
+    if (!derivationPath) derivationPath = "44'/501'/0'"
+    else if (!isNaN(Number(derivationPath))) derivationPath = `44'/501'/${derivationPath}'`
+    return (await LedgerSolanaWallet.create(derivationPath)) as SolanaWallet
+  } else if (existsSync(walletOpt)) {
+    wallet = hexlify(new Uint8Array(JSON.parse(readFileSync(walletOpt, 'utf8'))))
+  }
+  return new SolanaWallet(
+    Keypair.fromSecretKey(wallet.startsWith('0x') ? getBytes(wallet) : bs58.decode(wallet)),
+  )
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "lib": ["ES2023"],
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "verbatimModuleSyntax": true,
+    "erasableSyntaxOnly": true,
+    "resolveJsonModule": true
+  }
+}