@chainlink/ccip-sdk 0.97.0 → 1.1.0

package/src/evm/messages.ts

@@ -3,25 +3,16 @@ import type {
   AbiParametersToPrimitiveTypes,
   ExtractAbiEvent,
 } from 'abitype'
-import {
-  type Addressable,
-  type BytesLike,
-  type Result,
-  dataSlice,
-  hexlify,
-  toBigInt,
-  toNumber,
-} from 'ethers'
+import type { Addressable, Result } from 'ethers'
 import type { Simplify } from 'type-fest'
 
-import { CCIPMessageDecodeError } from '../errors/index.ts'
 import type { EVMExtraArgsV2 } from '../extra-args.ts'
-import type { CCIPVersion, ChainFamily, MergeArrayElements } from '../types.ts'
-import { decodeAddress, getDataBytes, networkInfo } from '../utils.ts'
+import type { CCIPVersion, MergeArrayElements } from '../types.ts'
 import type EVM2EVMOnRamp_1_5_ABI from './abi/OnRamp_1_5.ts'
 import type OnRamp_1_6_ABI from './abi/OnRamp_1_6.ts'
 import type OnRamp_2_0_ABI from './abi/OnRamp_2_0.ts'
 import { defaultAbiCoder } from './const.ts'
+import type { MessageV1 } from '../messages.ts'
 
 /** Utility type that cleans up address types to just `string`. */
 export type CleanAddressable<T> = T extends string | Addressable
@@ -32,279 +23,6 @@ export type CleanAddressable<T> = T extends string | Addressable
       ? { readonly [K in keyof T]: CleanAddressable<T[K]> }
       : T
 
-/** Token transfer in MessageV1 format. */
-export type TokenTransferV1 = {
-  amount: bigint
-  sourcePoolAddress: string
-  sourceTokenAddress: string
-  destTokenAddress: string
-  tokenReceiver: string
-  extraData: string
-}
-
-/** MessageV1 struct matching the Solidity MessageV1Codec format. */
-export type MessageV1 = {
-  sourceChainSelector: bigint
-  destChainSelector: bigint
-  messageNumber: bigint
-  executionGasLimit: number
-  ccipReceiveGasLimit: number
-  finality: number
-  ccvAndExecutorHash: string
-  onRampAddress: string
-  offRampAddress: string
-  sender: string
-  receiver: string
-  destBlob: string
-  tokenTransfer: readonly TokenTransferV1[]
-  data: string
-}
-
-/**
- * Decodes a TokenTransferV1 from bytes.
- * @param encoded - The encoded bytes.
- * @param offset - The starting offset.
- * @param sourceFamily - The source chain family for source addresses.
- * @param destFamily - The destination chain family for dest addresses.
- * @returns The decoded token transfer and the new offset.
- */
-function decodeTokenTransferV1(
-  encoded: Uint8Array,
-  offset: number,
-  sourceFamily: ChainFamily,
-  destFamily: ChainFamily,
-): { tokenTransfer: TokenTransferV1; newOffset: number } {
-  // version (1 byte)
-  if (offset >= encoded.length) throw new CCIPMessageDecodeError('TOKEN_TRANSFER_VERSION')
-  const version = encoded[offset++]!
-  if (version !== 1) throw new CCIPMessageDecodeError(`Invalid encoding version: ${version}`)
-
-  // amount (32 bytes)
-  if (offset + 32 > encoded.length) throw new CCIPMessageDecodeError('TOKEN_TRANSFER_AMOUNT')
-  const amount = toBigInt(dataSlice(encoded, offset, offset + 32))
-  offset += 32
-
-  // sourcePoolAddressLength and sourcePoolAddress
-  if (offset >= encoded.length) {
-    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_SOURCE_POOL_LENGTH')
-  }
-  const sourcePoolAddressLength = encoded[offset++]!
-  if (offset + sourcePoolAddressLength > encoded.length) {
-    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_SOURCE_POOL_CONTENT')
-  }
-  const sourcePoolAddress = decodeAddress(
-    dataSlice(encoded, offset, offset + sourcePoolAddressLength),
-    sourceFamily,
-  )
-  offset += sourcePoolAddressLength
-
-  // sourceTokenAddressLength and sourceTokenAddress
-  if (offset >= encoded.length) {
-    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_SOURCE_TOKEN_LENGTH')
-  }
-  const sourceTokenAddressLength = encoded[offset++]!
-  if (offset + sourceTokenAddressLength > encoded.length) {
-    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_SOURCE_TOKEN_CONTENT')
-  }
-  const sourceTokenAddress = decodeAddress(
-    dataSlice(encoded, offset, offset + sourceTokenAddressLength),
-    sourceFamily,
-  )
-  offset += sourceTokenAddressLength
-
-  // destTokenAddressLength and destTokenAddress
-  if (offset >= encoded.length) {
-    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_DEST_TOKEN_LENGTH')
-  }
-  const destTokenAddressLength = encoded[offset++]!
-  if (offset + destTokenAddressLength > encoded.length) {
-    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_DEST_TOKEN_CONTENT')
-  }
-  const destTokenAddress = decodeAddress(
-    dataSlice(encoded, offset, offset + destTokenAddressLength),
-    destFamily,
-  )
-  offset += destTokenAddressLength
-
-  // tokenReceiverLength and tokenReceiver
-  if (offset >= encoded.length) {
-    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_TOKEN_RECEIVER_LENGTH')
-  }
-  const tokenReceiverLength = encoded[offset++]!
-  if (offset + tokenReceiverLength > encoded.length) {
-    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_TOKEN_RECEIVER_CONTENT')
-  }
-  const tokenReceiver = decodeAddress(
-    dataSlice(encoded, offset, offset + tokenReceiverLength),
-    destFamily,
-  )
-  offset += tokenReceiverLength
-
-  // extraDataLength and extraData
-  if (offset + 2 > encoded.length) {
-    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_EXTRA_DATA_LENGTH')
-  }
-  const extraDataLength = toNumber(dataSlice(encoded, offset, offset + 2))
-  offset += 2
-  if (offset + extraDataLength > encoded.length) {
-    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_EXTRA_DATA_CONTENT')
-  }
-  const extraData = hexlify(dataSlice(encoded, offset, offset + extraDataLength))
-  offset += extraDataLength
-
-  return {
-    tokenTransfer: {
-      amount,
-      sourcePoolAddress,
-      sourceTokenAddress,
-      destTokenAddress,
-      tokenReceiver,
-      extraData,
-    },
-    newOffset: offset,
-  }
-}
-
-/**
- * Decodes a MessageV1 from bytes following the v1 protocol format.
- * @param encodedMessage - The encoded message bytes to decode.
- * @returns The decoded MessageV1 struct.
- */
-export function decodeMessageV1(encodedMessage: BytesLike): MessageV1 {
-  const MESSAGE_V1_BASE_SIZE = 77
-  const encoded = getDataBytes(encodedMessage)
-
-  if (encoded.length < MESSAGE_V1_BASE_SIZE) throw new CCIPMessageDecodeError('MESSAGE_MIN_SIZE')
-
-  const version = encoded[0]!
-  if (version !== 1) throw new CCIPMessageDecodeError(`Invalid encoding version: ${version}`)
-
-  // sourceChainSelector (8 bytes, big endian)
-  const sourceChainSelector = toBigInt(dataSlice(encoded, 1, 9))
-
-  // destChainSelector (8 bytes, big endian)
-  const destChainSelector = toBigInt(dataSlice(encoded, 9, 17))
-
-  // Get chain families for address decoding
-  const sourceNetworkInfo = networkInfo(sourceChainSelector)
-  const destNetworkInfo = networkInfo(destChainSelector)
-  const sourceFamily = sourceNetworkInfo.family
-  const destFamily = destNetworkInfo.family
-
-  // messageNumber (8 bytes, big endian)
-  const messageNumber = toBigInt(dataSlice(encoded, 17, 25))
-
-  // executionGasLimit (4 bytes, big endian)
-  const executionGasLimit = toNumber(dataSlice(encoded, 25, 29))
-
-  // ccipReceiveGasLimit (4 bytes, big endian)
-  const ccipReceiveGasLimit = toNumber(dataSlice(encoded, 29, 33))
-
-  // finality (2 bytes, big endian)
-  const finality = toNumber(dataSlice(encoded, 33, 35))
-
-  // ccvAndExecutorHash (32 bytes)
-  const ccvAndExecutorHash = hexlify(dataSlice(encoded, 35, 67))
-
-  // onRampAddressLength and onRampAddress
-  let offset = 67
-  if (offset >= encoded.length) throw new CCIPMessageDecodeError('MESSAGE_ONRAMP_ADDRESS_LENGTH')
-  const onRampAddressLength = encoded[offset++]!
-  if (offset + onRampAddressLength > encoded.length) {
-    throw new CCIPMessageDecodeError('MESSAGE_ONRAMP_ADDRESS_CONTENT')
-  }
-  const onRampAddress = decodeAddress(
-    dataSlice(encoded, offset, offset + onRampAddressLength),
-    sourceFamily,
-  )
-  offset += onRampAddressLength
-
-  // offRampAddressLength and offRampAddress
-  if (offset >= encoded.length) throw new CCIPMessageDecodeError('MESSAGE_OFFRAMP_ADDRESS_LENGTH')
-  const offRampAddressLength = encoded[offset++]!
-  if (offset + offRampAddressLength > encoded.length) {
-    throw new CCIPMessageDecodeError('MESSAGE_OFFRAMP_ADDRESS_CONTENT')
-  }
-  const offRampAddress = decodeAddress(
-    dataSlice(encoded, offset, offset + offRampAddressLength),
-    destFamily,
-  )
-  offset += offRampAddressLength
-
-  // senderLength and sender
-  if (offset >= encoded.length) throw new CCIPMessageDecodeError('MESSAGE_SENDER_LENGTH')
-  const senderLength = encoded[offset++]!
-  if (offset + senderLength > encoded.length) {
-    throw new CCIPMessageDecodeError('MESSAGE_SENDER_CONTENT')
-  }
-  const sender = decodeAddress(dataSlice(encoded, offset, offset + senderLength), sourceFamily)
-  offset += senderLength
-
-  // receiverLength and receiver
-  if (offset >= encoded.length) throw new CCIPMessageDecodeError('MESSAGE_RECEIVER_LENGTH')
-  const receiverLength = encoded[offset++]!
-  if (offset + receiverLength > encoded.length) {
-    throw new CCIPMessageDecodeError('MESSAGE_RECEIVER_CONTENT')
-  }
-  const receiver = decodeAddress(dataSlice(encoded, offset, offset + receiverLength), destFamily)
-  offset += receiverLength
-
-  // destBlobLength and destBlob
-  if (offset + 2 > encoded.length) throw new CCIPMessageDecodeError('MESSAGE_DEST_BLOB_LENGTH')
-  const destBlobLength = toNumber(dataSlice(encoded, offset, offset + 2))
-  offset += 2
-  if (offset + destBlobLength > encoded.length) {
-    throw new CCIPMessageDecodeError('MESSAGE_DEST_BLOB_CONTENT')
-  }
-  const destBlob = hexlify(dataSlice(encoded, offset, offset + destBlobLength))
-  offset += destBlobLength
-
-  // tokenTransferLength and tokenTransfer
-  if (offset + 2 > encoded.length) throw new CCIPMessageDecodeError('MESSAGE_TOKEN_TRANSFER_LENGTH')
-  const tokenTransferLength = toNumber(dataSlice(encoded, offset, offset + 2))
-  offset += 2
-
-  // Decode token transfer, which is either 0 or 1
-  const tokenTransfer: TokenTransferV1[] = []
-  if (tokenTransferLength > 0) {
-    const expectedEnd = offset + tokenTransferLength
-    const result = decodeTokenTransferV1(encoded, offset, sourceFamily, destFamily)
-    tokenTransfer.push(result.tokenTransfer)
-    offset = result.newOffset
-    if (offset !== expectedEnd) throw new CCIPMessageDecodeError('MESSAGE_TOKEN_TRANSFER_CONTENT')
-  }
-
-  // dataLength and data
-  if (offset + 2 > encoded.length) throw new CCIPMessageDecodeError('MESSAGE_DATA_LENGTH')
-  const dataLength = toNumber(dataSlice(encoded, offset, offset + 2))
-  offset += 2
-  if (offset + dataLength > encoded.length) {
-    throw new CCIPMessageDecodeError('MESSAGE_DATA_CONTENT')
-  }
-  const data = hexlify(dataSlice(encoded, offset, offset + dataLength))
-  offset += dataLength
-
-  // Ensure we've consumed all bytes
-  if (offset !== encoded.length) throw new CCIPMessageDecodeError('MESSAGE_FINAL_OFFSET')
-
-  return {
-    sourceChainSelector,
-    destChainSelector,
-    messageNumber,
-    executionGasLimit,
-    ccipReceiveGasLimit,
-    finality,
-    ccvAndExecutorHash,
-    onRampAddress,
-    offRampAddress,
-    sender,
-    receiver,
-    destBlob,
-    tokenTransfer,
-    data,
-  }
-}
-
 // v1.2-v1.5 Message ()
 type EVM2AnyMessageRequested = CleanAddressable<
   AbiParametersToPrimitiveTypes<

package/src/evm/offchain.ts

@@ -1,90 +1,5 @@
-import { type Addressable, type Log, EventFragment } from 'ethers'
-
-import { getLbtcAttestation, getUsdcAttestation } from '../offchain.ts'
-import type {
-  CCIPMessage,
-  CCIPRequest,
-  NetworkType,
-  OffchainTokenData,
-  WithLogger,
-} from '../types.ts'
-import { networkInfo } from '../utils.ts'
-import { defaultAbiCoder, interfaces, requestsFragments } from './const.ts'
-import { type SourceTokenData, parseSourceTokenData } from './messages.ts'
-
-const BURNED_EVENT_1_5 = interfaces.TokenPool_v1_5.getEvent('Burned')!
-const BURNED_EVENT_1_6 = interfaces.TokenPool_v1_6.getEvent('LockedOrBurned')!
-const BURNED_EVENT_TOPIC_HASHES = new Set([BURNED_EVENT_1_5.topicHash, BURNED_EVENT_1_6.topicHash])
-
-const USDC_EVENT = EventFragment.from('MessageSent(bytes message)')
-const TRANSFER_EVENT = EventFragment.from('Transfer(address from, address to, uint256 value)')
-
-export const LBTC_EVENT = EventFragment.from(
-  'DepositToBridge(address fromAddress, bytes32 toAddress, bytes32 payloadHash, bytes payload)',
-)
-export const LBTC_EVENT_V2 = EventFragment.from(
-  'DepositToBridge(address fromAddress, bytes32 toAddress, bytes32 payloadHash)',
-)
-const LBTC_EVENTS_HASHES = new Set([LBTC_EVENT.topicHash, LBTC_EVENT_V2.topicHash])
-
-/**
- * Fetch offchain token data for all transfers in request
- *
- * @param request - Request (or subset of) to fetch offchainTokenData for
- * @returns Array of byte arrays, one per transfer in request
- */
-export async function fetchEVMOffchainTokenData(
-  request: Pick<CCIPRequest, 'tx'> & {
-    message: CCIPMessage
-    log: Pick<CCIPRequest['log'], 'index'>
-  },
-  ctx: WithLogger,
-): Promise<OffchainTokenData[]> {
-  const { networkType } = networkInfo(request.message.sourceChainSelector)
-  // there's a chance there are other CCIPSendRequested in same tx,
-  // and they may contain USDC transfers as well, so we select
-  // any USDC logs after that and before our CCIPSendRequested
-  const prevCcipRequestIdx =
-    request.tx.logs.find(
-      ({ topics, index }) => topics[0]! in requestsFragments && index < request.log.index,
-    )?.index ?? -1
-  const usdcRequestLogs = request.tx.logs.filter(
-    ({ index }) => prevCcipRequestIdx < index && index < request.log.index,
-  ) as Log[]
-
-  const offchainTokenData: OffchainTokenData[] = request.message.tokenAmounts.map(
-    () => undefined, // default tokenData
-  )
-  const usdcTokenData = await getUsdcTokenData(
-    request.message.tokenAmounts,
-    usdcRequestLogs,
-    networkType,
-    ctx,
-  )
-  let lbtcTokenData: OffchainTokenData[] = []
-  try {
-    let tokenAmounts
-    if ('sourceTokenData' in request.message) {
-      tokenAmounts = request.message.sourceTokenData.map(parseSourceTokenData)
-    } else {
-      tokenAmounts = request.message.tokenAmounts
-    }
-    //for lbtc we distinguish logs by hash in event, so we can pass all of them
-    lbtcTokenData = await getLbtcTokenData(tokenAmounts, request.tx.logs as Log[], networkType, ctx)
-  } catch (_) {
-    // pass
-  }
-
-  for (let i = 0; i < offchainTokenData.length; i++) {
-    if (usdcTokenData[i]) {
-      offchainTokenData[i] = usdcTokenData[i]
-    } else if (lbtcTokenData[i]) {
-      offchainTokenData[i] = lbtcTokenData[i]
-    }
-  }
-
-  return offchainTokenData
-}
+import type { OffchainTokenData } from '../types.ts'
+import { defaultAbiCoder } from './const.ts'
 
 /**
  * Encodes offchain token data for EVM execution.
@@ -99,107 +14,3 @@ export function encodeEVMOffchainTokenData(data: OffchainTokenData): string {
   }
   return '0x'
 }
-
-/**
- * Try to fetch USDC attestations for transfers, return undefined in position if can't
- *
- * @param tokenAmounts - all tokenAmounts to try
- * @param allLogsInRequest - all other logs in same tx as CCIPSendRequested
- * @param networkType - network type (mainnet or testnet)
- * @returns array where each position is either the attestation for that transfer or undefined
- **/
-async function getUsdcTokenData(
-  tokenAmounts: CCIPMessage['tokenAmounts'],
-  allLogsInRequest: Pick<Log, 'topics' | 'address' | 'data'>[],
-  networkType: NetworkType,
-  { logger = console }: WithLogger = {},
-): Promise<OffchainTokenData[]> {
-  const attestations: OffchainTokenData[] = []
-
-  const messageSentPerTokenAndPool = allLogsInRequest.reduce((acc, log, i, arr) => {
-    // for our MessageSent of interest (USDC-like), the token is the contract
-    // which emitted a (burn) Transfer immediately before this event, and the pool emitted a Burned
-    // event 2 events after
-    const transferLog = arr[i - 1]
-    const poolLog = arr[i + 2]
-    if (
-      log.topics[0] !== USDC_EVENT.topicHash ||
-      transferLog?.topics[0] !== TRANSFER_EVENT.topicHash ||
-      !poolLog?.topics.length ||
-      !BURNED_EVENT_TOPIC_HASHES.has(poolLog.topics[0]!)
-    ) {
-      return acc
-    }
-    const token = transferLog.address
-    const pool = poolLog.address
-    acc.set(token, [...(acc.get(token) ?? []), log])
-    acc.set(pool, [...(acc.get(pool) ?? []), log])
-    return acc
-  }, new Map<string | Addressable, (typeof allLogsInRequest)[number][]>())
-
-  for (const [i, tokenAmount] of tokenAmounts.entries()) {
-    const tokenOrPool = 'token' in tokenAmount ? tokenAmount.token : tokenAmount.sourcePoolAddress
-
-    // what if there are more USDC transfers of this same token after this one?
-    const tokenTransfersCountAfter = tokenAmounts.filter(
-      (ta, j) => ('token' in ta ? ta.token : ta.sourcePoolAddress) === tokenOrPool && j > i,
-    ).length
-
-    let messageSentLog: (typeof allLogsInRequest)[number] | undefined
-    const messageSents = messageSentPerTokenAndPool.get(tokenOrPool)
-    if (messageSents) {
-      // look from the end (near our request), but skip MessageSents for further transfers
-      messageSentLog = messageSents[messageSents.length - 1 - tokenTransfersCountAfter]
-    }
-
-    let tokenData: OffchainTokenData
-    if (messageSentLog) {
-      let message
-      try {
-        message = defaultAbiCoder.decode(USDC_EVENT.inputs, messageSentLog.data)[0] as string
-        const attestation = await getUsdcAttestation(message, networkType)
-        tokenData = {
-          _tag: 'usdc',
-          message,
-          attestation,
-        }
-        // encoding of OffchainTokenData to be done as part of Chain.executeReceipt
-      } catch (err) {
-        // maybe not a USDC transfer, or not ready
-        logger.warn(`❌ EVM CCTP: Failed to fetch attestation for message:`, message, err)
-      }
-    }
-    attestations.push(tokenData)
-  }
-
-  return attestations
-}
-
-/**
- * Try to fetch LBTC attestations for transfers, return undefined in position if can't or not required
- **/
-async function getLbtcTokenData(
-  tokenAmounts: readonly Pick<SourceTokenData, 'extraData'>[],
-  allLogsInRequest: readonly Pick<Log, 'topics' | 'address' | 'data'>[],
-  networkType: NetworkType,
-  { logger = console }: WithLogger = {},
-): Promise<OffchainTokenData[]> {
-  const lbtcDepositHashes = new Set(
-    allLogsInRequest
-      .filter(({ topics }) => LBTC_EVENTS_HASHES.has(topics[0]!))
-      .map(({ topics }) => topics[3]),
-  )
-  return Promise.all(
-    tokenAmounts.map(async ({ extraData }) => {
-      // Attestation is required when SourceTokenData.extraData is 32 bytes long ('0x' + 64 hex chars)
-      // otherwise attestation is not required
-      if (lbtcDepositHashes.has(extraData)) {
-        try {
-          return { _tag: 'lbtc', extraData, ...(await getLbtcAttestation(extraData, networkType)) }
-        } catch (err) {
-          logger.warn(`❌ EVM LBTC: Failed to fetch attestation for message:`, extraData, err)
-        }
-      }
-    }),
-  )
-}

package/src/gas.ts

@@ -20,6 +20,10 @@ export type EstimateMessageInput = {
   messageId?: string
   /** optional sender: zero address will be used if omitted */
   sender?: string
+  /** optional onRampAddress */
+  onRampAddress?: string
+  /** optional offRampAddress */
+  offRampAddress?: string
   /** optional data: zero bytes will be used if omitted */
   data?: BytesLike
   /**
@@ -89,26 +93,29 @@ export async function estimateReceiveExecution({
   if (!dest.estimateReceiveExecution)
     throw new CCIPMethodUnsupportedError(dest.constructor.name, 'estimateReceiveExecution')
 
-  let onRamp, offRamp: string
-  try {
-    const tnv = await source.typeAndVersion(routerOrRamp)
-    if (!tnv[0].includes('OnRamp'))
-      onRamp = await source.getOnRampForRouter(routerOrRamp, dest.network.chainSelector)
-    else onRamp = routerOrRamp
-    offRamp = await discoverOffRamp(source, dest, onRamp, source)
-  } catch (sourceErr) {
+  let onRamp: string, offRamp: string
+  if (message.onRampAddress) onRamp = message.onRampAddress
+  if (message.offRampAddress) offRamp = message.offRampAddress
+  if (!onRamp! || !offRamp!)
     try {
-      const tnv = await dest.typeAndVersion(routerOrRamp)
-      if (!tnv[0].includes('OffRamp'))
-        throw new CCIPContractTypeInvalidError(routerOrRamp, tnv[2], ['OffRamp'])
-      offRamp = routerOrRamp
-      const onRamps = await dest.getOnRampsForOffRamp(offRamp, source.network.chainSelector)
-      if (!onRamps.length) throw new CCIPOnRampRequiredError()
-      onRamp = onRamps[onRamps.length - 1]!
-    } catch {
-      throw sourceErr // re-throw original error
+      const tnv = await source.typeAndVersion(routerOrRamp)
+      if (!tnv[0].includes('OnRamp'))
+        onRamp = await source.getOnRampForRouter(routerOrRamp, dest.network.chainSelector)
+      else onRamp = routerOrRamp
+      offRamp = await discoverOffRamp(source, dest, onRamp, source)
+    } catch (sourceErr) {
+      try {
+        const tnv = await dest.typeAndVersion(routerOrRamp)
+        if (!tnv[0].includes('OffRamp'))
+          throw new CCIPContractTypeInvalidError(routerOrRamp, tnv[2], ['OffRamp'])
+        offRamp = routerOrRamp
+        const onRamps = await dest.getOnRampsForOffRamp(offRamp, source.network.chainSelector)
+        if (!onRamps.length) throw new CCIPOnRampRequiredError()
+        onRamp = onRamps[onRamps.length - 1]!
+      } catch {
+        throw sourceErr // re-throw original error
+      }
     }
-  }
 
   const destTokenAmounts = await Promise.all(
     (message.tokenAmounts ?? []).map(async (ta) => {
@@ -127,7 +134,8 @@ export async function estimateReceiveExecution({
         dest.getTokenInfo(tokenAmount.destTokenAddress),
       ])
       const destAmount =
-        (tokenAmount.amount * 10n ** BigInt(destDecimals)) / 10n ** BigInt(sourceDecimals)
+        (tokenAmount.amount * BigInt(10) ** BigInt(destDecimals)) /
+        BigInt(10) ** BigInt(sourceDecimals)
       if (destAmount === 0n)
         throw new CCIPTokenDecimalsInsufficientError(
           tokenAmount.destTokenAddress,

package/src/index.ts

@@ -13,7 +13,12 @@ export type {
   CCIPAPIClientContext,
   LaneLatencyResponse,
 } from './api/index.ts'
-export { CCIPAPIClient, DEFAULT_API_BASE_URL } from './api/index.ts'
+export {
+  CCIPAPIClient,
+  DEFAULT_API_BASE_URL,
+  SDK_VERSION,
+  SDK_VERSION_HEADER,
+} from './api/index.ts'
 
 export type {
   ApiRetryConfig,
@@ -22,6 +27,7 @@ export type {
   ChainGetter,
   ChainStatic,
   GetBalanceOpts,
+  LaneFeatures,
   LogFilter,
   RateLimiterState,
   RegistryTokenConfig,
@@ -29,7 +35,7 @@ export type {
   TokenPoolConfig,
   TokenPoolRemote,
 } from './chain.ts'
-export { DEFAULT_API_RETRY_CONFIG } from './chain.ts'
+export { DEFAULT_API_RETRY_CONFIG, LaneFeature } from './chain.ts'
 export { calculateManualExecProof, discoverOffRamp } from './execution.ts'
 export {
   type EVMExtraArgsV1,
@@ -41,12 +47,14 @@ export {
   encodeExtraArgs,
 } from './extra-args.ts'
 export { estimateReceiveExecution } from './gas.ts'
+export { getOffchainTokenData } from './offchain.ts'
 export { decodeMessage, getMessagesForSender, sourceToDestTokenAddresses } from './requests.ts'
 export {
   type CCIPExecution,
   type CCIPMessage,
   type CCIPRequest,
   type CCIPVerifications,
+  type ChainLog,
   type ChainTransaction,
   type CommitReport,
   type ExecutionInput,