@chainlink/ccip-sdk 0.97.0 → 1.0.0

package/src/offchain.ts

@@ -1,56 +1,79 @@
-import { keccak256 } from 'ethers'
+import { type BytesLike, dataLength, dataSlice, getBytes, toNumber } from 'ethers'
+import type { PickDeep } from 'type-fest'
 
 import {
   CCIPLbtcAttestationNotApprovedError,
   CCIPLbtcAttestationNotFoundError,
   CCIPUsdcAttestationError,
 } from './errors/index.ts'
-import { NetworkType } from './types.ts'
+import { parseSourceTokenData } from './evm/messages.ts'
+import { type CCIPRequest, type OffchainTokenData, type WithLogger, NetworkType } from './types.ts'
+import { networkInfo } from './utils.ts'
 
 const CIRCLE_API_URL = {
-  mainnet: 'https://iris-api.circle.com/v1',
-  testnet: 'https://iris-api-sandbox.circle.com/v1',
+  mainnet: 'https://iris-api.circle.com',
+  testnet: 'https://iris-api-sandbox.circle.com',
 }
 
 type CctpAttestationResponse =
   | { error: 'string' }
-  | { status: 'pending_confirmations' }
-  | { status: 'complete'; attestation: string }
-
-const LOMBARD_API_URL = {
-  mainnet: 'https://mainnet.prod.lombard.finance',
-  testnet: 'https://gastald-testnet.prod.lombard.finance',
-}
-
-type LombardAttestation =
-  | { status: 'NOTARIZATION_STATUS_SESSION_APPROVED'; message_hash: string; attestation: string }
-  | { status: string; message_hash: string }
-type LombardAttestationsResponse = { attestations: Array<LombardAttestation> }
+  | {
+      messages: {
+        status: 'pending_confirmations' | 'complete'
+        eventNonce?: string
+        attestation: string
+        message: string
+      }[]
+    }
 
 /**
- * Returns the USDC attestation for a given MessageSent Log
- * https://developers.circle.com/stablecoins/reference/getattestation
+ * Returns the USDC attestation for a given tokenAmount.extraData and txHash
+ * https://developers.circle.com/cctp/quickstarts/transfer-usdc-ethereum-to-arc#3-3-retrieve-attestation
  *
- * @param message - payload of USDC MessageSent(bytes message) event
+ * @param opts - CCTPv2 options
  * @param networkType - network type (mainnet or testnet)
- * @returns USDC/CCTP attestation bytes
+ * @returns USDC/CCTP attestation and message
  */
 export async function getUsdcAttestation(
-  message: string,
+  opts: {
+    /** CCTP sourceDomain */
+    sourceDomain: number
+    /** CCTP burn eventNonce */
+    nonce: number
+    /** burn txHash, same as CCIP request */
+    txHash: string
+  },
   networkType: NetworkType,
-): Promise<string> {
-  const msgHash = keccak256(message)
-
+): Promise<{ attestation: string; message: string }> {
+  const { sourceDomain, nonce, txHash } = opts
   const circleApiBaseUrl =
     networkType === NetworkType.Mainnet ? CIRCLE_API_URL.mainnet : CIRCLE_API_URL.testnet
-  const res = await fetch(`${circleApiBaseUrl}/attestations/${msgHash}`)
+  const res = await fetch(
+    `${circleApiBaseUrl}/v2/messages/${sourceDomain}?transactionHash=${txHash}`,
+  )
   const json = (await res.json()) as CctpAttestationResponse
-  if (!('status' in json) || json.status !== 'complete' || !json.attestation) {
-    throw new CCIPUsdcAttestationError(msgHash, json)
+  let att
+  if ('messages' in json) {
+    att = json.messages.find((m) => m.status === 'complete' && m.eventNonce === nonce.toString())
   }
-  return json.attestation
+  if (!att?.message) throw new CCIPUsdcAttestationError(txHash, json, { context: opts })
+  return att
+}
+
+const LOMBARD_API_URL = {
+  mainnet: 'https://mainnet.prod.lombard.finance',
+  testnet: 'https://gastald-testnet.prod.lombard.finance',
 }
 
+type LombardAttestation =
+  | {
+      status: 'NOTARIZATION_STATUS_SESSION_APPROVED'
+      message_hash: string
+      attestation: string
+    }
+  | { status: string; message_hash: string }
+type LombardAttestationsResponse = { attestations: Array<LombardAttestation> }
+
 /**
  * Returns the LBTC attestation for a given payload hash
  *
@@ -86,3 +109,77 @@ export async function getLbtcAttestation(
   }
   return attestation
 }
+
+/**
+ * Fetch CCIPv1 offchain token data for USDC and LBTC tokenAmounts
+ * @param request - CCIPRequest containing tx.hash and message
+ * @returns Promise resolving to an OffchainTokenData for each tokenAmount
+ */
+export async function getOffchainTokenData(
+  request: PickDeep<CCIPRequest, 'tx.hash' | `message`>,
+  { logger = console }: WithLogger = {},
+): Promise<OffchainTokenData[]> {
+  const { networkType } = networkInfo(request.message.sourceChainSelector)
+
+  function looksUsdcData(extraData: BytesLike) {
+    if (dataLength(extraData) !== 64) return
+    // USDCTokenPool's extraData is a packed `SourceTokenDataPayloadV1{uint64 nonce, uint32 sourceDomain}`,
+    // which we need to query CCTPv2 (by sourceDomain and txHash) and to filter by nonce among messages,
+    // if more than one in tx
+    let nonce, sourceDomain
+    try {
+      // those toNumber conversions throw early in case the bytearray don't look like small numbers
+      nonce = toNumber(dataSlice(extraData, 0, 32))
+      sourceDomain = toNumber(dataSlice(extraData, 32, 32 + 32))
+      return { nonce, sourceDomain } // maybe USDC
+    } catch {
+      // not USDC
+    }
+  }
+
+  function looksLbtcData(extraData: BytesLike) {
+    // LBTC returns `message_hash`/`payloadHash` directly as `bytes32 extraData`
+    if (
+      dataLength(extraData) === 32 &&
+      getBytes(extraData, 'extraData').filter(Boolean).length > 20 // looks like a hash
+    )
+      return true
+  }
+
+  return Promise.all(
+    request.message.tokenAmounts.map(async (tokenAmount, i) => {
+      let extraData
+      if ('extraData' in tokenAmount) {
+        extraData = tokenAmount.extraData
+      } else if ('sourceTokenData' in request.message) {
+        // v1.2..v1.5
+        if (dataLength(request.message.sourceTokenData[i]!) === 64) {
+          extraData = request.message.sourceTokenData[i]
+        } else {
+          ;({ extraData } = parseSourceTokenData(request.message.sourceTokenData[i]!))
+        }
+      }
+      if (!extraData) return
+      const usdcOpts = looksUsdcData(extraData)
+      if (usdcOpts) {
+        try {
+          const usdcAttestation = await getUsdcAttestation(
+            { ...usdcOpts, txHash: request.tx.hash },
+            networkType,
+          )
+          return { _tag: 'usdc', extraData, ...usdcAttestation }
+        } catch (err) {
+          // maybe not a USDC transfer, or not ready
+          logger.warn(`❌ CCTP: Failed to fetch attestation for message:`, request.message, err)
+        }
+      } else if (looksLbtcData(extraData)) {
+        try {
+          const lbtcAttestation = await getLbtcAttestation(extraData, networkType)
+          return { _tag: 'lbtc', extraData, ...lbtcAttestation }
+        } catch (err) {
+          logger.warn(`❌ LBTC: Failed to fetch attestation for message:`, extraData, err)
+        }
+      }
+    }),
+  )
+}

package/src/requests.ts

@@ -19,8 +19,8 @@ import {
   type CCIPMessage,
   type CCIPRequest,
   type CCIPVersion,
+  type ChainLog,
   type ChainTransaction,
-  type Log_,
   type MessageInput,
   ChainFamily,
 } from './types.ts'
@@ -78,7 +78,6 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
     data_.sourceNetworkInfo?.chainSelector
   if (!sourceChainSelector) throw new CCIPMessageInvalidError(data)
   data_.sourceChainSelector ??= sourceChainSelector
-  data_.nonce ??= 0n
   const sourceFamily = networkInfo(sourceChainSelector).family
 
   const destChainSelector =
@@ -181,7 +180,7 @@ export function decodeMessage(data: string | Uint8Array | Record<string, unknown
   // try bytearray decoding on each supported chain
   for (const chain of Object.values(supportedChains)) {
     try {
-      const decoded = chain.decodeMessage({ data } as unknown as Log_)
+      const decoded = chain.decodeMessage({ data } as unknown as ChainLog)
       if (decoded) return decoded
     } catch (_) {
       // continue

package/src/solana/idl/1.6.0/BASE_TOKEN_POOL.ts

@@ -3,7 +3,7 @@
 //   .then((res) => res.text())
 //   .then((text) => text.trim())
 export type BaseTokenPool = {
-  version: '1.6.0'
+  version: '1.6.1'
   name: 'base_token_pool'
   instructions: []
   types: [
@@ -868,7 +868,7 @@ export type BaseTokenPool = {
 }
 
 export const IDL: BaseTokenPool = {
-  version: '1.6.0',
+  version: '1.6.1',
   name: 'base_token_pool',
   instructions: [],
   types: [

package/src/solana/idl/1.6.0/BURN_MINT_TOKEN_POOL.ts

@@ -3,7 +3,7 @@
 //   .then((res) => res.text())
 //   .then((text) => text.trim())
 export type BurnmintTokenPool = {
-  version: '1.6.0'
+  version: '1.6.1'
   name: 'burnmint_token_pool'
   instructions: [
     {
@@ -951,7 +951,7 @@ export type BurnmintTokenPool = {
 }
 
 export const IDL: BurnmintTokenPool = {
-  version: '1.6.0',
+  version: '1.6.1',
   name: 'burnmint_token_pool',
   instructions: [
     {

package/src/solana/idl/1.6.0/CCIP_CCTP_TOKEN_POOL.ts

@@ -3,7 +3,7 @@
 //   .then((res) => res.text())
 //   .then((text) => text.trim())
 export type CctpTokenPool = {
-  version: '1.6.0'
+  version: '1.6.1'
   name: 'cctp_token_pool'
   instructions: [
     {
@@ -1376,7 +1376,7 @@ export type CctpTokenPool = {
 }
 
 export const IDL: CctpTokenPool = {
-  version: '1.6.0',
+  version: '1.6.1',
   name: 'cctp_token_pool',
   instructions: [
     {

package/src/solana/idl/1.6.0/CCIP_COMMON.ts

@@ -3,7 +3,7 @@
 //   .then((res) => res.text())
 //   .then((text) => text.trim())
 export type CcipCommon = {
-  version: '0.1.1'
+  version: '1.6.1'
   name: 'ccip_common'
   instructions: []
   accounts: [
@@ -102,11 +102,26 @@ export type CcipCommon = {
       name: 'InvalidSVMAddress'
       msg: 'Invalid SVM address'
     },
+    {
+      code: 10011
+      name: 'InvalidTVMAddress'
+      msg: 'Invalid TVM address'
+    },
+    {
+      code: 10012
+      name: 'InvalidAptosAddress'
+      msg: 'Invalid Aptos address'
+    },
+    {
+      code: 10013
+      name: 'InvalidSuiAddress'
+      msg: 'Invalid Sui address'
+    },
   ]
 }
 
 export const IDL: CcipCommon = {
-  version: '0.1.1',
+  version: '1.6.1',
   name: 'ccip_common',
   instructions: [],
   accounts: [
@@ -205,6 +220,21 @@ export const IDL: CcipCommon = {
       name: 'InvalidSVMAddress',
       msg: 'Invalid SVM address',
     },
+    {
+      code: 10011,
+      name: 'InvalidTVMAddress',
+      msg: 'Invalid TVM address',
+    },
+    {
+      code: 10012,
+      name: 'InvalidAptosAddress',
+      msg: 'Invalid Aptos address',
+    },
+    {
+      code: 10013,
+      name: 'InvalidSuiAddress',
+      msg: 'Invalid Sui address',
+    },
   ],
 }
 // generate:end

package/src/solana/idl/1.6.0/CCIP_OFFRAMP.ts

@@ -3,7 +3,7 @@
 //   .then((res) => res.text())
 //   .then((text) => text.trim())
 export type CcipOfframp = {
-  version: '0.1.1'
+  version: '1.6.1'
   name: 'ccip_offramp'
   constants: [
     {
@@ -2748,7 +2748,7 @@ export type CcipOfframp = {
 }
 
 export const IDL: CcipOfframp = {
-  version: '0.1.1',
+  version: '1.6.1',
   name: 'ccip_offramp',
   constants: [
     {

package/src/solana/idl/1.6.0/CCIP_ROUTER.ts

@@ -8,7 +8,7 @@
 //     else throw new Error('isMut is already true, no need for this workaround anymore');
 //   }))
 export type CcipRouter = {
-  version: '0.1.1'
+  version: '1.6.1'
   name: 'ccip_router'
   docs: [
     'The `ccip_router` module contains the implementation of the Cross-Chain Interoperability Protocol (CCIP) Router.',
@@ -2339,7 +2339,7 @@ export type CcipRouter = {
 }
 
 export const IDL: CcipRouter = {
-  version: '0.1.1',
+  version: '1.6.1',
   name: 'ccip_router',
   docs: [
     'The `ccip_router` module contains the implementation of the Cross-Chain Interoperability Protocol (CCIP) Router.',

package/src/solana/index.ts

@@ -77,15 +77,14 @@ import {
   type CCIPMessage,
   type CCIPRequest,
   type CCIPVerifications,
+  type ChainLog,
   type ChainTransaction,
   type CommitReport,
   type ExecutionInput,
   type ExecutionReceipt,
   type Lane,
-  type Log_,
   type MergeArrayElements,
   type NetworkInfo,
-  type OffchainTokenData,
   type WithLogger,
   CCIPVersion,
   ChainFamily,
@@ -113,7 +112,6 @@ import { IDL as CCIP_CCTP_TOKEN_POOL } from './idl/1.6.0/CCIP_CCTP_TOKEN_POOL.ts
 import { IDL as CCIP_OFFRAMP_IDL } from './idl/1.6.0/CCIP_OFFRAMP.ts'
 import { IDL as CCIP_ROUTER_IDL } from './idl/1.6.0/CCIP_ROUTER.ts'
 import { getTransactionsForAddress } from './logs.ts'
-import { fetchSolanaOffchainTokenData } from './offchain.ts'
 import { generateUnsignedCcipSend, getFee } from './send.ts'
 import { type CCIPMessage_V1_6_Solana, type UnsignedSolanaTx, isWallet } from './types.ts'
 import {
@@ -160,7 +158,7 @@ const unknownTokens: { [mint: string]: string } = {
 }
 
 /** Solana-specific log structure with transaction reference and log level. */
-export type SolanaLog = Log_ & { tx: SolanaTransaction; data: string; level: number }
+export type SolanaLog = ChainLog & { tx: SolanaTransaction; data: string; level: number }
 /** Solana-specific transaction structure with versioned transaction response. */
 export type SolanaTransaction = MergeArrayElements<
   ChainTransaction,
@@ -430,13 +428,13 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    *   - `watch`: Watch for new logs
    *   - `programs`: Special option to allow querying by address of interest, but yielding matching
    *     logs from specific (string address) program or any (true)
-   * @returns AsyncIterableIterator of parsed Log_ objects.
+   * @returns AsyncIterableIterator of parsed ChainLog objects.
    * @throws {@link CCIPLogsAddressRequiredError} if address is not provided
    * @throws {@link CCIPTopicsInvalidError} if topics contain invalid values
    */
   async *getLogs(
     opts: LogFilter & { programs?: string[] | true },
-  ): AsyncGenerator<Log_ & { tx: SolanaTransaction }> {
+  ): AsyncGenerator<ChainLog & { tx: SolanaTransaction }> {
     let programs: true | string[]
     if (!opts.address) {
       throw new CCIPLogsAddressRequiredError()
@@ -895,7 +893,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * @throws {@link CCIPLogDataMissingError} if log data is missing
    */
   static decodeCommits(
-    log: Pick<Log_, 'data'>,
+    log: Pick<ChainLog, 'data'>,
     lane?: Omit<Lane, 'destChainSelector'>,
   ): CommitReport[] | undefined {
     // Check if this is a CommitReportAccepted event by looking at the discriminant
@@ -950,7 +948,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * @throws {@link CCIPLogDataMissingError} if log data is missing
    * @throws {@link CCIPExecutionStateInvalidError} if execution state is invalid
    */
-  static decodeReceipt(log: Pick<Log_, 'data' | 'tx' | 'index'>): ExecutionReceipt | undefined {
+  static decodeReceipt(log: Pick<ChainLog, 'data' | 'tx' | 'index'>): ExecutionReceipt | undefined {
     // Check if this is a ExecutionStateChanged event by looking at the discriminant
     if (!log.data || typeof log.data !== 'string') {
       throw new CCIPLogDataMissingError()
@@ -983,7 +981,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     } else throw new CCIPExecutionStateInvalidError(util.inspect(decoded.data.state))
 
     let returnData
-    if (log.tx) {
+    if (log.tx?.logs) {
       // use only last receipt per tx+message (i.e. skip intermediary InProgress=1 states for Solana)
       const laterReceiptLog = log.tx.logs
         .filter((l) => l.index > log.index)
@@ -1107,11 +1105,6 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return (await this.getMessagesInTx(await this.getTransaction(hash)))[0]!
   }
 
-  /** {@inheritDoc Chain.getOffchainTokenData} */
-  async getOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]> {
-    return fetchSolanaOffchainTokenData(request, this)
-  }
-
   /**
    * {@inheritDoc Chain.generateUnsignedExecute}
    * @returns instructions - array of instructions to execute the report
@@ -1209,13 +1202,13 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       if (Array.isArray(data)) {
         if (data.every((e) => typeof e === 'string')) return getErrorFromLogs(data)
         else if (data.every((e) => typeof e === 'object' && 'data' in e && 'address' in e))
-          return getErrorFromLogs(data as Log_[])
+          return getErrorFromLogs(data as ChainLog[])
       } else if (typeof data === 'object') {
         if ('transactionLogs' in data && 'transactionMessage' in data) {
-          const parsed = getErrorFromLogs(data.transactionLogs as Log_[] | string[])
+          const parsed = getErrorFromLogs(data.transactionLogs as ChainLog[] | string[])
           if (parsed) return { message: data.transactionMessage, ...parsed }
         }
-        if ('logs' in data) return getErrorFromLogs(data.logs as Log_[] | string[])
+        if ('logs' in data) return getErrorFromLogs(data.logs as ChainLog[] | string[])
       } else if (typeof data === 'string') {
         const parsedExtraArgs = this.decodeExtraArgs(getDataBytes(data))
         if (parsedExtraArgs) return parsedExtraArgs

package/src/solana/offchain.ts

@@ -1,29 +1,10 @@
-import { type BN, BorshCoder } from '@coral-xyz/anchor'
-import type { PublicKey } from '@solana/web3.js'
+import { BorshCoder } from '@coral-xyz/anchor'
 import { hexlify } from 'ethers'
 
-import {
-  CCIPCctpDecodeError,
-  CCIPCctpMultipleEventsError,
-  CCIPDataFormatUnsupportedError,
-} from '../errors/index.ts'
-import { getUsdcAttestation } from '../offchain.ts'
-import type { CCIPMessage, CCIPRequest, OffchainTokenData, WithLogger } from '../types.ts'
-import { bytesToBuffer, networkInfo, util } from '../utils.ts'
+import type { OffchainTokenData } from '../types.ts'
+import { bytesToBuffer } from '../utils.ts'
 import { IDL as BASE_TOKEN_POOL } from './idl/1.6.0/BASE_TOKEN_POOL.ts'
 import { IDL as CCTP_TOKEN_POOL } from './idl/1.6.0/CCIP_CCTP_TOKEN_POOL.ts'
-import type { SolanaLog, SolanaTransaction } from './index.ts'
-import { hexDiscriminator } from './utils.ts'
-
-interface CcipCctpMessageSentEvent {
-  originalSender: PublicKey
-  remoteChainSelector: BN
-  msgTotalNonce: BN
-  eventAddress: PublicKey
-  sourceDomain: number
-  cctpNonce: BN
-  messageSentBytes: Uint8Array
-}
 
 interface CcipCctpMessageAndAttestation {
   message: {
@@ -38,84 +19,6 @@ const cctpTokenPoolCoder = new BorshCoder({
   errors: [...BASE_TOKEN_POOL.errors, ...CCTP_TOKEN_POOL.errors],
 })
 
-/**
- * Analyzes a Solana transaction to extract CcipCctpMessageSentEvent, fetch Circle attestation,
- * and encode the data in the format required by the destination chain.
- * @param request - CCIP request containing transaction data and chain routing info.
- * @param logger - Logger instance for logging messages.
- * @returns Array of encoded offchain token data (only one supported for Solana right now).
- * @throws Error if transaction hash is missing or CcipCctpMessageSentEvent parsing fails.
- */
-export async function fetchSolanaOffchainTokenData(
-  request: Pick<CCIPRequest, 'tx' | 'lane'> & {
-    message: CCIPMessage
-    log: Pick<CCIPRequest['log'], 'topics' | 'index' | 'transactionHash' | 'address'>
-  },
-  { logger = console }: WithLogger = {},
-): Promise<OffchainTokenData[]> {
-  if (!request.message.tokenAmounts.length) {
-    return []
-  }
-
-  if (request.message.tokenAmounts.length > 1) {
-    throw new CCIPDataFormatUnsupportedError(
-      `Expected at most 1 token transfer, found ${request.message.tokenAmounts.length}`,
-    )
-  }
-
-  const { networkType } = networkInfo(request.lane.sourceChainSelector)
-  const txSignature = request.log.transactionHash
-
-  // Parse Solana transaction to find CCTP event
-  const tx = request.tx as SolanaTransaction
-  const log = request.log as SolanaLog
-  const logMessages = tx.tx.meta!.logMessages!
-  // there may have multiple ccipSend calls in same tx;
-  // use `invoke [level]` to filter only logs inside this call
-  const requestInvokeIdx = logMessages.findLastIndex(
-    (l, i) => i < log.index && l === `Program ${request.log.address} invoke [${log.level}]`,
-  )
-  const cctpEvents = []
-  for (const l of tx.logs) {
-    if (requestInvokeIdx >= l.index || l.index >= log.index) continue
-    if (l.topics[0] !== hexDiscriminator('CcipCctpMessageSentEvent')) continue
-    const decoded = cctpTokenPoolCoder.events.decode(l.data)
-    if (!decoded) throw new CCIPCctpDecodeError(util.inspect(l))
-    cctpEvents.push(decoded.data as unknown as CcipCctpMessageSentEvent)
-  }
-  const offchainTokenData: OffchainTokenData[] = request.message.tokenAmounts.map(() => undefined)
-
-  // If no CcipCctpMessageSentEvent found, return defaults so we don't block execution
-  if (cctpEvents.length === 0) {
-    logger.debug('No USDC/CCTP events found')
-    return offchainTokenData
-  }
-
-  // Currently, we only support ONE token per transfer
-  if (cctpEvents.length > 1) {
-    throw new CCIPCctpMultipleEventsError(cctpEvents.length, txSignature)
-  }
-
-  // NOTE: assuming USDC token is the first (and only) token in the CCIP message, we will process the CCTP event.
-  // If later multi-token transfers support is added, we need to add more info in order to match each token with it's event and offchainTokenData.
-  const cctpEvent = cctpEvents[0]
-  if (cctpEvent) {
-    const message = hexlify(cctpEvent.messageSentBytes)
-    try {
-      // Extract message bytes to fetch circle's attestation and then encode offchainTokenData.
-      const attestation = await getUsdcAttestation(message, networkType)
-
-      offchainTokenData[0] = { _tag: 'usdc', message, attestation }
-    } catch (error) {
-      logger.warn(`❌ Solana CCTP: Failed to fetch attestation for ${txSignature}:`, message, error)
-    }
-  }
-
-  logger.debug('Got Solana offchain token data', offchainTokenData)
-
-  return offchainTokenData
-}
-
 /**
  * Encodes CCTP message and attestation
  *

package/src/solana/utils.ts

@@ -26,7 +26,7 @@ import {
   CCIPTokenMintNotFoundError,
   CCIPTransactionNotFinalizedError,
 } from '../errors/index.ts'
-import type { Log_, WithLogger } from '../types.ts'
+import type { ChainLog, WithLogger } from '../types.ts'
 import { getDataBytes, sleep } from '../utils.ts'
 import type { IDL as BASE_TOKEN_POOL_IDL } from './idl/1.6.0/BASE_TOKEN_POOL.ts'
 import type { UnsignedSolanaTx, Wallet } from './types.ts'
@@ -143,7 +143,7 @@ export function camelToSnakeCase(str: string): string {
     .replace(/^_/, '')
 }
 
-type ParsedLog = Pick<Log_, 'topics' | 'index' | 'address' | 'data'> & {
+type ParsedLog = Pick<ChainLog, 'topics' | 'index' | 'address' | 'data'> & {
   data: string
   level: number
 }
@@ -160,7 +160,7 @@ type ParsedLog = Pick<Log_, 'topics' | 'index' | 'address' | 'data'> & {
  * This function:
  * 1. Tracks the program call stack to determine which program emitted each log
  * 2. Extracts the first 8 bytes from base64 "Program data:" logs as topics (event discriminants)
- * 3. Converts logs to EVM-compatible Log_ format for CCIP compatibility
+ * 3. Converts logs to EVM-compatible ChainLog format for CCIP compatibility
  * 4. Returns ALL logs from the transaction - filtering should be done by the caller
  *
  * @param logs - Array of logMessages from Solana transaction
@@ -215,7 +215,10 @@ export function parseSolanaLogs(logs: readonly string[]): ParsedLog[] {
  * @returns Parsed error info with program and error details.
  */
 export function getErrorFromLogs(
-  logs_: readonly string[] | readonly Pick<Log_, 'address' | 'index' | 'data' | 'topics'>[] | null,
+  logs_:
+    | readonly string[]
+    | readonly Pick<ChainLog, 'address' | 'index' | 'data' | 'topics'>[]
+    | null,
 ): { program: string; [k: string]: string } | undefined {
   if (!logs_?.length) return
   let logs
@@ -229,7 +232,7 @@ export function getErrorFromLogs(
       (acc, l) =>
         // if acc is empty (i.e. on last log), or it is emitted by the same program and not a Program data:
         !acc.length || (l.address === acc[0]!.address && !l.topics.length) ? [l, ...acc] : acc,
-      [] as Pick<Log_, 'address' | 'index' | 'data'>[],
+      [] as Pick<ChainLog, 'address' | 'index' | 'data'>[],
     )
     .map(({ data }) => data as string)
     .reduceRight(