@chainlink/ccip-sdk 0.95.0 → 0.97.0

package/src/evm/messages.ts

@@ -1,21 +1,310 @@
-import type { AbiParametersToPrimitiveTypes, ExtractAbiEvent } from 'abitype'
-import type { Addressable, Result } from 'ethers'
+import type {
+  AbiParameterToPrimitiveType,
+  AbiParametersToPrimitiveTypes,
+  ExtractAbiEvent,
+} from 'abitype'
+import {
+  type Addressable,
+  type BytesLike,
+  type Result,
+  dataSlice,
+  hexlify,
+  toBigInt,
+  toNumber,
+} from 'ethers'
+import type { Simplify } from 'type-fest'
 
+import { CCIPMessageDecodeError } from '../errors/index.ts'
 import type { EVMExtraArgsV2 } from '../extra-args.ts'
-import type { CCIPVersion, MergeArrayElements } from '../types.ts'
+import type { CCIPVersion, ChainFamily, MergeArrayElements } from '../types.ts'
+import { decodeAddress, getDataBytes, networkInfo } from '../utils.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'
 
 /** Utility type that cleans up address types to just `string`. */
 export type CleanAddressable<T> = T extends string | Addressable
   ? string
-  : T extends Record<string, unknown>
+  : T extends { [K: string]: unknown } | [...unknown[]]
     ? { [K in keyof T]: CleanAddressable<T[K]> }
-    : T extends readonly unknown[]
-      ? readonly CleanAddressable<T[number]>[]
+    : T extends { readonly [K: string]: unknown } | readonly [...unknown[]]
+      ? { 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<
@@ -50,12 +339,35 @@ export type CCIPMessage_V1_2_EVM = EVM2AnyMessageRequested
 /** v1.6 EVM specialization with EVMExtraArgsV2 and tokenAmounts.*.destGasAmount. */
 export type CCIPMessage_V1_6_EVM = CCIPMessage_V1_6 & EVMExtraArgsV2
 
+type MessageSentV2EventParams = ExtractAbiEvent<typeof OnRamp_2_0_ABI, 'CCIPMessageSent'>['inputs']
+type CCIPMessageSentV2 = {
+  [N in MessageSentV2EventParams[number]['name']]: CleanAddressable<
+    AbiParameterToPrimitiveType<MessageSentV2EventParams[number] & { readonly name: N }>
+  >
+}
+
+/**
+ * CCIP v2.0 (fka v1.7) Message
+ */
+export type CCIPMessage_V2_0 = Simplify<
+  CCIPMessageSentV2 &
+    Omit<MessageV1, 'tokenTransfer'> & {
+      tokenAmounts: MessageV1['tokenTransfer']
+      sequenceNumber: MessageV1['messageNumber']
+      feeTokenAmount: bigint
+    }
+>
+
 /** Union type for CCIP EVM messages across versions. */
-export type CCIPMessage_EVM<V extends CCIPVersion = CCIPVersion> = V extends typeof CCIPVersion.V1_2
-  ? CCIPMessage_V1_2_EVM
-  : V extends typeof CCIPVersion.V1_5
-    ? CCIPMessage_V1_5_EVM
-    : CCIPMessage_V1_6_EVM
+export type CCIPMessage_EVM<V extends CCIPVersion = CCIPVersion> = V extends typeof CCIPVersion.V2_0
+  ? CCIPMessage_V2_0
+  : V extends typeof CCIPVersion.V1_6
+    ? CCIPMessage_V1_6_EVM
+    : V extends typeof CCIPVersion.V1_5
+      ? CCIPMessage_V1_5_EVM
+      : V extends typeof CCIPVersion.V1_2
+        ? CCIPMessage_V1_2_EVM
+        : never
 
 const SourceTokenData =
   'tuple(bytes sourcePoolAddress, bytes destTokenAddress, bytes extraData, uint64 destGasAmount)'

package/src/evm/offchain.ts

@@ -63,7 +63,7 @@ export async function fetchEVMOffchainTokenData(
   )
   let lbtcTokenData: OffchainTokenData[] = []
   try {
-    let tokenAmounts: readonly SourceTokenData[]
+    let tokenAmounts
     if ('sourceTokenData' in request.message) {
       tokenAmounts = request.message.sourceTokenData.map(parseSourceTokenData)
     } else {
@@ -179,7 +179,7 @@ async function getUsdcTokenData(
  * Try to fetch LBTC attestations for transfers, return undefined in position if can't or not required
  **/
 async function getLbtcTokenData(
-  tokenAmounts: readonly SourceTokenData[],
+  tokenAmounts: readonly Pick<SourceTokenData, 'extraData'>[],
   allLogsInRequest: readonly Pick<Log, 'topics' | 'address' | 'data'>[],
   networkType: NetworkType,
   { logger = console }: WithLogger = {},

package/src/evm/types.ts

@@ -1,4 +1,4 @@
-import type { TransactionRequest } from 'ethers'
+import { type TransactionRequest, Result } from 'ethers'
 
 import type { ChainFamily } from '../types.ts'
 
@@ -7,5 +7,23 @@ import type { ChainFamily } from '../types.ts'
  */
 export type UnsignedEVMTx = {
   family: typeof ChainFamily.EVM
-  transactions: Pick<TransactionRequest, 'from' | 'to' | 'data'>[]
+  transactions: Pick<TransactionRequest, 'from' | 'to' | 'data' | 'gasLimit'>[]
+}
+
+/**
+ * Convert a Result or Promise to an object
+ * @internal
+ */
+export function resultToObject<T>(o: T): T {
+  if (o instanceof Promise) return o.then(resultToObject) as T
+  if (!(o instanceof Result)) return o
+  if (o.length === 0) return o.toArray() as T
+  try {
+    const obj = o.toObject()
+    if (!Object.keys(obj).every((k) => /^_+\d*$/.test(k)))
+      return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, resultToObject(v)])) as T
+  } catch (_) {
+    // fallthrough
+  }
+  return o.toArray().map(resultToObject) as T
 }

package/src/execution.ts

@@ -1,23 +1,13 @@
 import { memoize } from 'micro-memoize'
 
-import type { Chain, ChainStatic } from './chain.ts'
+import type { Chain } from './chain.ts'
 import {
   CCIPMerkleRootMismatchError,
   CCIPMessageNotInBatchError,
   CCIPOffRampNotFoundError,
 } from './errors/index.ts'
 import { Tree, getLeafHasher, proofFlagsToBits } from './hasher/index.ts'
-import {
-  type CCIPCommit,
-  type CCIPExecution,
-  type CCIPMessage,
-  type CCIPRequest,
-  type CCIPVersion,
-  type ExecutionReport,
-  type Lane,
-  type WithLogger,
-  ExecutionState,
-} from './types.ts'
+import type { CCIPMessage, CCIPVersion, Lane, WithLogger } from './types.ts'
 
 /**
  * Pure/sync function to calculate/generate OffRamp.executeManually report for messageIds
@@ -28,6 +18,38 @@ import {
  * @param merkleRoot - Optional merkleRoot of the CommitReport, for validation
  * @param ctx - Context for logging
  * @returns ManualExec report arguments
+ * @throws CCIPMessageNotInBatchError - When the messageId is not found in the provided batch
+ * @throws CCIPMerkleRootMismatchError - When calculated merkle root doesn't match the provided one
+ *
+ * @remarks
+ * This is a pure/sync function that performs no I/O - all data must be pre-fetched.
+ * It builds a merkle tree from the messages, generates a proof for the target messageId,
+ * and optionally validates against the provided merkleRoot.
+ *
+ * The returned proof can be used with `execute` to manually execute a stuck message.
+ *
+ * @example
+ * ```typescript
+ * import { calculateManualExecProof, EVMChain } from '@chainlink/ccip-sdk'
+ *
+ * // Fetch the request and all messages in its batch
+ * const request = (await source.getMessagesInTx(txHash))[0]
+ * const verifications = await dest.getVerifications({ offRamp, request })
+ * const messages = await source.getMessagesInBatch(request, commit.report)
+ *
+ * // Calculate proof for manual execution
+ * const proof = calculateManualExecProof(
+ *   messages,
+ *   request.lane,
+ *   request.message.messageId,
+ *   commit.report.merkleRoot
+ * )
+ * console.log('Merkle root:', proof.merkleRoot)
+ * console.log('Proofs:', proof.proofs)
+ * ```
+ * @see {@link discoverOffRamp} - Find the OffRamp for manual execution
+ * @see {@link execute} - Execute the report on destination chain
+ * @see {@link generateUnsignedExecute} - Build unsigned execution tx
  **/
 export function calculateManualExecProof<V extends CCIPVersion = CCIPVersion>(
   messagesInBatch: readonly CCIPMessage<V>[],
@@ -35,7 +57,7 @@ export function calculateManualExecProof<V extends CCIPVersion = CCIPVersion>(
   messageId: string,
   merkleRoot?: string,
   ctx?: WithLogger,
-): Omit<ExecutionReport, 'offchainTokenData' | 'message'> {
+) {
   const hasher = getLeafHasher(lane, ctx)
 
   const msgIdx = messagesInBatch.findIndex((message) => message.messageId === messageId)
@@ -64,6 +86,30 @@ export function calculateManualExecProof<V extends CCIPVersion = CCIPVersion>(
   }
 }
 
+/**
+ * Discover the OffRamp address for a given OnRamp and destination chain.
+ * Results are memoized for performance.
+ *
+ * @param source - Source chain instance.
+ * @param dest - Destination chain instance.
+ * @param onRamp - OnRamp contract address on source chain.
+ * @param ctx - Optional context with logger.
+ * @returns OffRamp address on destination chain.
+ * @throws CCIPOffRampNotFoundError - When no matching OffRamp is found for the OnRamp
+ * @example
+ * ```typescript
+ * import { discoverOffRamp, EVMChain } from '@chainlink/ccip-sdk'
+ *
+ * const source = await EVMChain.fromUrl('https://rpc.sepolia.org')
+ * const dest = await EVMChain.fromUrl('https://rpc.fuji.avax.network')
+ *
+ * const offRamp = await discoverOffRamp(source, dest, onRampAddress)
+ * console.log('OffRamp on destination:', offRamp)
+ * ```
+ * @see {@link calculateManualExecProof} - Use with OffRamp for manual execution
+ * @see {@link execute} - Execute on destination chain
+ * @see {@link getExecutionReceipts} - Check execution status
+ */
 export const discoverOffRamp = memoize(
   async function discoverOffRamp_(
     source: Chain,
@@ -77,26 +123,76 @@ export const discoverOffRamp = memoize(
       dest.network.chainSelector,
     )
     for (const offRamp of sourceOffRamps) {
-      const destOnRamp = await source.getOnRampForOffRamp(offRamp, dest.network.chainSelector)
-      const destRouter = await dest.getRouterForOnRamp(destOnRamp, source.network.chainSelector)
-      const destOffRamps = await dest.getOffRampsForRouter(destRouter, source.network.chainSelector)
-      for (const offRamp of destOffRamps) {
-        const offRampsOnRamp = await dest.getOnRampForOffRamp(offRamp, source.network.chainSelector)
+      let destOnRamps
+      try {
+        destOnRamps = await source.getOnRampsForOffRamp(offRamp, dest.network.chainSelector)
+      } catch (err) {
         logger.debug(
-          'discoverOffRamp: found, from',
-          {
-            sourceOnRamp: onRamp,
-            sourceRouter,
-            sourceOffRamps,
-            destOnRamp,
-            destOffRamps,
-            offRampsOnRamp,
-          },
-          '=',
+          'discoverOffRamp: skipping offRamp',
           offRamp,
+          '(no valid source chain config)',
+          err,
         )
-        if (offRampsOnRamp === onRamp) {
-          return offRamp
+        continue
+      }
+      for (const destOnRamp of destOnRamps) {
+        const destRouter = await dest.getRouterForOnRamp(destOnRamp, source.network.chainSelector)
+        const destOffRamps = await dest.getOffRampsForRouter(
+          destRouter,
+          source.network.chainSelector,
+        )
+        for (const offRamp of destOffRamps) {
+          let offRampsOnRamps
+          try {
+            offRampsOnRamps = await dest.getOnRampsForOffRamp(offRamp, source.network.chainSelector)
+          } catch (err) {
+            logger.debug(
+              'discoverOffRamp: skipping dest offRamp',
+              offRamp,
+              '(no valid source chain config)',
+              err,
+            )
+            continue
+          }
+          for (const offRampsOnRamp of offRampsOnRamps) {
+            logger.debug(
+              'discoverOffRamp: found, from',
+              {
+                sourceOnRamp: onRamp,
+                sourceRouter,
+                sourceOffRamps,
+                destOnRamp,
+                destOffRamps,
+                offRampsOnRamp,
+              },
+              '=',
+              offRamp,
+            )
+            for (const offRamp of destOffRamps) {
+              const offRampsOnRamps = await dest.getOnRampsForOffRamp(
+                offRamp,
+                source.network.chainSelector,
+              )
+              for (const offRampsOnRamp of offRampsOnRamps) {
+                logger.debug(
+                  'discoverOffRamp: found, from',
+                  {
+                    sourceOnRamp: onRamp,
+                    sourceRouter,
+                    sourceOffRamps,
+                    destOnRamp,
+                    destOffRamps,
+                    offRampsOnRamps,
+                  },
+                  '=',
+                  offRamp,
+                )
+                if (offRampsOnRamp === onRamp) {
+                  return offRamp
+                }
+              }
+            }
+          }
         }
       }
     }
@@ -107,44 +203,3 @@ export const discoverOffRamp = memoize(
       [source.network.chainSelector, dest.network.chainSelector, onRamp] as const,
   },
 )
-
-/**
- * Generic implementation for fetching ExecutionReceipts for given requests.
- * If more than one request is given, may yield them interleaved.
- * Completes as soon as there's no more work to be done.
- *
- * Two possible behaviors:
- * - if `startBlock|startTime` is given, pages forward from that block up;
- *   completes when success (final) receipt is found for all requests (or reach latest block)
- * - otherwise, pages backwards and returns only the most recent receipt per request;
- *   completes when receipts for all requests were seen
- *
- * @param dest - Provider to page through.
- * @param offRamp - OffRamp contract address.
- * @param request - CCIP request to search executions for.
- * @param commit - Optional commit info to narrow down search.
- * @param hints - Optional hints (e.g., `page` for getLogs pagination range).
- */
-export async function* getExecutionReceipts(
-  dest: Chain,
-  offRamp: string,
-  request: CCIPRequest,
-  commit?: CCIPCommit,
-  hints?: { page?: number },
-): AsyncGenerator<CCIPExecution> {
-  const onlyLast = !commit?.log.blockNumber && !request.tx.timestamp // backwards
-  for await (const log of dest.getLogs({
-    startBlock: commit?.log.blockNumber,
-    startTime: request.tx.timestamp,
-    address: offRamp,
-    topics: ['ExecutionStateChanged'],
-    ...hints,
-  })) {
-    const receipt = (dest.constructor as ChainStatic).decodeReceipt(log)
-    if (!receipt || receipt.messageId !== request.message.messageId) continue
-
-    const timestamp = log.tx?.timestamp ?? (await dest.getBlockTimestamp(log.blockNumber))
-    yield { receipt, log, timestamp }
-    if (onlyLast || receipt.state === ExecutionState.Success) break
-  }
-}