@chainlink/ccip-sdk 0.96.0 → 0.97.0

package/src/extra-args.ts

@@ -9,7 +9,7 @@ export const EVMExtraArgsV1Tag = id('CCIP EVMExtraArgsV1').substring(0, 10) as '
 /** Tag identifier for EVMExtraArgsV2 encoding. */
 export const EVMExtraArgsV2Tag = id('CCIP EVMExtraArgsV2').substring(0, 10) as '0x181dcf10'
 /** Tag identifier for GenericExtraArgsV3 encoding (tightly packed binary format). */
-export const GenericExtraArgsV3Tag = '0x302326cb' as const
+export const GenericExtraArgsV3Tag = id('CCIP GenericExtraArgsV3').substring(0, 10) as '0xa69dd4aa'
 /** Tag identifier for SVMExtraArgsV1 encoding. */
 export const SVMExtraArgsV1Tag = id('CCIP SVMExtraArgsV1').substring(0, 10) as '0x1f3b3aba'
 /** Tag identifier for SuiExtraArgsV1 encoding. */
@@ -145,6 +145,7 @@ export type ExtraArgs =
  * Encodes extra arguments for CCIP messages.
  * The args are *to* a dest network, but are encoded as a message *from* this source chain.
  * E.g. Solana uses Borsh to encode extraArgs in its produced requests, even those targeting EVM.
+ *
  * @param args - Extra arguments to encode
  * @param from - Source chain family for encoding format (defaults to EVM)
  * @returns Encoded extra arguments as hex string
@@ -152,12 +153,16 @@ export type ExtraArgs =
  *
  * @example
  * ```typescript
+ * import { encodeExtraArgs } from '@chainlink/ccip-sdk'
+ *
  * const encoded = encodeExtraArgs({
  *   gasLimit: 200_000n,
  *   allowOutOfOrderExecution: true,
  * })
- * // Returns: '0x181dcf10...'
+ * console.log('Encoded:', encoded) // '0x181dcf10...'
  * ```
+ *
+ * @see {@link decodeExtraArgs} - Decode extra arguments from bytes
  */
 export function encodeExtraArgs(args: ExtraArgs, from: ChainFamily = ChainFamily.EVM): string {
   const chain = supportedChains[from]
@@ -175,11 +180,16 @@ export function encodeExtraArgs(args: ExtraArgs, from: ChainFamily = ChainFamily
  *
  * @example
  * ```typescript
+ * import { decodeExtraArgs } from '@chainlink/ccip-sdk'
+ *
  * const decoded = decodeExtraArgs('0x181dcf10...')
  * if (decoded?._tag === 'EVMExtraArgsV2') {
- *   console.log(decoded.gasLimit, decoded.allowOutOfOrderExecution)
+ *   console.log('Gas limit:', decoded.gasLimit)
+ *   console.log('Out of order:', decoded.allowOutOfOrderExecution)
  * }
  * ```
+ *
+ * @see {@link encodeExtraArgs} - Encode extra arguments to bytes
  */
 export function decodeExtraArgs(
   data: BytesLike,

package/src/gas.ts

@@ -4,6 +4,7 @@ import type { Chain } from './chain.ts'
 import {
   CCIPContractTypeInvalidError,
   CCIPMethodUnsupportedError,
+  CCIPOnRampRequiredError,
   CCIPTokenDecimalsInsufficientError,
 } from './errors/index.ts'
 import { discoverOffRamp } from './execution.ts'
@@ -50,11 +51,34 @@ export type EstimateReceiveExecutionOpts = {
 
 /**
  * Estimate CCIP gasLimit needed to execute a request on a contract receiver.
- * @param opts - Options for estimation: source and dest chains, router or ramp address, and message
- * @returns Estimated gasLimit.
+ *
+ * @param opts - {@link EstimateReceiveExecutionOpts} for estimation
+ * @returns Estimated gasLimit
+ *
  * @throws {@link CCIPMethodUnsupportedError} if dest chain doesn't support estimation
  * @throws {@link CCIPContractTypeInvalidError} if routerOrRamp is not a valid contract type
  * @throws {@link CCIPTokenDecimalsInsufficientError} if dest token has insufficient decimals
+ *
+ * @example
+ * ```typescript
+ * import { estimateReceiveExecution, 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 gasLimit = await estimateReceiveExecution({
+ *   source,
+ *   dest,
+ *   routerOrRamp: '0xRouter...',
+ *   message: {
+ *     sender: '0x...',
+ *     receiver: '0x...',
+ *     data: '0x...',
+ *     tokenAmounts: [],
+ *   },
+ * })
+ * console.log('Estimated gas:', gasLimit)
+ * ```
  */
 export async function estimateReceiveExecution({
   source,
@@ -78,7 +102,9 @@ export async function estimateReceiveExecution({
       if (!tnv[0].includes('OffRamp'))
         throw new CCIPContractTypeInvalidError(routerOrRamp, tnv[2], ['OffRamp'])
       offRamp = routerOrRamp
-      onRamp = await dest.getOnRampForOffRamp(offRamp, source.network.chainSelector)
+      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
     }

package/src/index.ts

@@ -43,14 +43,14 @@ export {
 export { estimateReceiveExecution } from './gas.ts'
 export { decodeMessage, getMessagesForSender, sourceToDestTokenAddresses } from './requests.ts'
 export {
-  type CCIPCommit,
   type CCIPExecution,
   type CCIPMessage,
   type CCIPRequest,
+  type CCIPVerifications,
   type ChainTransaction,
   type CommitReport,
+  type ExecutionInput,
   type ExecutionReceipt,
-  type ExecutionReport,
   type Lane,
   type Logger,
   type MessageInput,

package/src/requests.ts

@@ -46,6 +46,14 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
     source_chain_selector?: string
     sourceChainSelector?: string
     extraArgs?: string | Record<string, unknown>
+    sequenceNumber?: bigint
+    messageNumber?: bigint
+    tokenTransfer?: {
+      destExecData: string
+      destGasAmount?: bigint
+      token?: string
+      sourceTokenAddress?: string
+    }[]
     tokenAmounts: {
       destExecData: string
       destGasAmount?: bigint
@@ -60,6 +68,7 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
         totalAmount: bigint
       }
     }
+    receipts?: { feeTokenAmount: bigint }[]
     sourceNetworkInfo?: { chainSelector: string }
     destNetworkInfo?: { chainSelector: string }
   }
@@ -82,7 +91,7 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
       ? BigInt(v as string | number | bigint)
       : k?.match(/(^dest.*address)|(receiver|offramp|accounts)/i)
         ? decodeAddress(v as BytesLike, destFamily)
-        : k?.match(/((source.*address)|sender|origin|onramp|(feetoken$)|(token.*address$))/i)
+        : k?.match(/((source.*address)|sender|issuer|origin|onramp|(feetoken$)|(token.*address$))/i)
           ? decodeAddress(v as BytesLike, sourceFamily)
           : v instanceof Uint8Array ||
               (Array.isArray(v) && v.length >= 4 && v.every((e) => typeof e === 'number'))
@@ -90,6 +99,10 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
             : v,
   ) as typeof data_
 
+  if (data_.tokenTransfer) {
+    data_.tokenAmounts = data_.tokenTransfer
+    delete data_.tokenTransfer
+  }
   for (const ta of data_.tokenAmounts) {
     if (ta.token && !ta.sourceTokenAddress) ta.sourceTokenAddress = ta.token
     if (!ta.token && ta.sourceTokenAddress) ta.token = ta.sourceTokenAddress
@@ -121,6 +134,15 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
     data_.feeToken = data_.fees.fixedFeesDetails.tokenAddress
     data_.feeTokenAmount = data_.fees.fixedFeesDetails.totalAmount
   }
+  if (data_.sequenceNumber == null && data_.messageNumber != null) {
+    data_.sequenceNumber = data_.messageNumber
+  }
+  if (!data_.feeTokenAmount && data_.receipts) {
+    data_.feeTokenAmount = data_.receipts.reduce(
+      (acc, receipt) => acc + receipt.feeTokenAmount,
+      BigInt(0),
+    )
+  }
 
   return data_ as unknown as CCIPMessage
 }
@@ -128,9 +150,24 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
 /**
  * Decodes hex strings, bytearrays, JSON strings and raw objects as CCIPMessages.
  * Does minimal validation, but converts objects in the format expected by ccip-tools-ts.
+ *
  * @param data - Data to decode (hex string, Uint8Array, JSON string, or object)
  * @returns Decoded CCIPMessage
  * @throws {@link CCIPMessageDecodeError} if data cannot be decoded as a valid message
+ * @throws {@link CCIPMessageInvalidError} if message structure is invalid or missing required fields
+ *
+ * @example
+ * ```typescript
+ * import { decodeMessage } from '@chainlink/ccip-sdk'
+ *
+ * // Decode from JSON string
+ * const message = decodeMessage('{"header":{"sourceChainSelector":"123",...}')
+ *
+ * // Decode from hex-encoded bytes
+ * const message = decodeMessage('0x...')
+ *
+ * console.log('Message ID:', message.messageId)
+ * ```
  */
 export function decodeMessage(data: string | Uint8Array | Record<string, unknown>): CCIPMessage {
   if (
@@ -171,6 +208,8 @@ export function buildMessageForDest(message: MessageInput, dest: ChainFamily): A
  * @returns CCIP requests (messages) in the transaction (at least one)
  * @throws {@link CCIPChainFamilyUnsupportedError} if chain family not supported for legacy messages
  * @throws {@link CCIPMessageNotFoundInTxError} if no CCIP messages found in transaction
+ *
+ * @see {@link getMessageById} - Search by messageId when tx hash unknown
  */
 export async function getMessagesInTx(source: Chain, tx: ChainTransaction): Promise<CCIPRequest[]> {
   // RPC fallback
@@ -194,17 +233,36 @@ export async function getMessagesInTx(source: Chain, tx: ChainTransaction): Prom
     }
     requests.push({ lane, message, log, tx })
   }
-  if (!requests.length) throw new CCIPMessageNotFoundInTxError(tx.hash)
+  if (!requests.length)
+    throw new CCIPMessageNotFoundInTxError(tx.hash, { context: { network: source.network.name } })
   return requests
 }
 
 /**
- * Fetch a CCIP message by its messageId from RPC (slow).
- * Should be called *after* generic Chain implementation, which fetches from API if available.
- * @param source - Provider to fetch logs from.
- * @param messageId - MessageId to search for.
- * @param opts - Optional hints for pagination (e.g., `address` for onRamp, `page` for pagination size).
- * @returns CCIPRequest with given messageId.
+ * Fetch a CCIP message by messageId from RPC logs (slow scan).
+ *
+ * This is the fallback implementation called by {@link Chain.getMessageById}
+ * when the API client is unavailable or fails.
+ *
+ * @param source - Source chain to scan logs from
+ * @param messageId - Message ID to search for
+ * @param opts - Optional hints (onRamp address narrows search, page controls batch size)
+ * @returns CCIPRequest matching the messageId
+ *
+ * @throws {@link CCIPMessageIdNotFoundError} if message not found after scanning all logs
+ *
+ * @example
+ *
+ * ```typescript
+ * import { getMessageById, EVMChain } from '@chainlink/ccip-sdk'
+ *
+ * const source = await EVMChain.fromUrl('https://rpc.sepolia.org')
+ * const request = await getMessageById(source, '0xabc123...', {
+ *   onRamp: '0xOnRampAddress...',
+ * })
+ * console.log(`Found: seqNr=${request.message.sequenceNumber}`)
+ * ```
+ *
  * @internal
  */
 export async function getMessageById(
@@ -249,9 +307,10 @@ const BLOCK_LOG_WINDOW_SIZE = 5000
  * Fetches all CCIP messages contained in a given commit batch.
  * @param source - The source chain.
  * @param request - The CCIP request containing lane and message info.
- * @param seqNrRange - Object containing minSeqNr and maxSeqNr for the batch range.
+ * @param range - Object containing minSeqNr and maxSeqNr for the batch range.
  * @param opts - Optional log filtering parameters.
  * @returns Array of messages in the batch.
+ * @see {@link getVerifications} - Get commit report to determine batch range
  */
 export async function getMessagesInBatch<
   C extends Chain,
@@ -293,6 +352,7 @@ export async function getMessagesInBatch<
       const message = (source.constructor as ChainStatic).decodeMessage(log)
       if (
         !message ||
+        !('sequenceNumber' in message) ||
         ('destChainSelector' in message &&
           message.destChainSelector !== request.lane.destChainSelector)
       )
@@ -314,6 +374,7 @@ export async function getMessagesInBatch<
       const message = (source.constructor as ChainStatic).decodeMessage(log)
       if (
         !message ||
+        !('sequenceNumber' in message) ||
         ('destChainSelector' in message &&
           message.destChainSelector !== request.lane.destChainSelector)
       )
@@ -339,6 +400,21 @@ export async function getMessagesInBatch<
  * @param filter - Log filter options.
  * @returns Async generator of CCIP requests.
  * @throws {@link CCIPChainFamilyUnsupportedError} if chain family not supported for legacy messages
+ *
+ * @example
+ * ```typescript
+ * import { getMessagesForSender, EVMChain } from '@chainlink/ccip-sdk'
+ *
+ * const chain = await EVMChain.fromUrl('https://rpc.sepolia.org')
+ *
+ * for await (const request of getMessagesForSender(chain, '0xSenderAddress', {})) {
+ *   console.log('Message ID:', request.message.messageId)
+ *   console.log('Destination:', request.lane.destChainSelector)
+ * }
+ * ```
+ *
+ * @see {@link getMessagesInTx} - Fetch from specific transaction
+ * @see {@link getMessageById} - Search by messageId
  */
 export async function* getMessagesForSender(
   source: Chain,
@@ -376,13 +452,33 @@ export async function* getMessagesForSender(
 }
 
 /**
- * Map source `token` to `sourcePoolAddress + destTokenAddress`.
- * @param source - Source chain.
- * @param destChainSelector - Destination network selector.
- * @param onRamp - Contract address.
- * @param sourceTokenAmount - tokenAmount object, usually containing `token` and `amount` properties.
- * @returns tokenAmount object with `sourcePoolAddress`, `sourceTokenAddress`, `destTokenAddress`, and remaining properties.
- * @throws {@link CCIPTokenNotInRegistryError} if token not found in registry
+ * Map source token to its pool address and destination token address.
+ *
+ * Resolves token routing by querying the TokenAdminRegistry and TokenPool
+ * to find the corresponding destination chain token.
+ *
+ * @param source - Source chain instance
+ * @param destChainSelector - Destination chain selector
+ * @param onRamp - OnRamp contract address
+ * @param sourceTokenAmount - Token amount object containing `token` and `amount`
+ * @returns Extended token amount with `sourcePoolAddress`, `sourceTokenAddress`, and `destTokenAddress`
+ *
+ * @throws {@link CCIPTokenNotInRegistryError} if token is not registered in TokenAdminRegistry
+ *
+ * @example
+ * ```typescript
+ * import { sourceToDestTokenAddresses, EVMChain } from '@chainlink/ccip-sdk'
+ *
+ * const source = await EVMChain.fromUrl('https://rpc.sepolia.org')
+ * const tokenAmount = await sourceToDestTokenAddresses(
+ *   source,
+ *   destChainSelector,
+ *   '0xOnRamp...',
+ *   { token: '0xLINK...', amount: 1000000000000000000n }
+ * )
+ * console.log(`Pool: ${tokenAmount.sourcePoolAddress}`)
+ * console.log(`Dest token: ${tokenAmount.destTokenAddress}`)
+ * ```
  */
 export async function sourceToDestTokenAddresses<S extends { token: string }>(
   source: Chain,

package/src/selectors.ts

@@ -1099,6 +1099,12 @@ const selectors: Selectors = {
     network_type: 'TESTNET',
     family: 'EVM',
   },
+  '46630': {
+    selector: 2032988798112970440n,
+    name: 'robinhood-testnet',
+    network_type: 'TESTNET',
+    family: 'EVM',
+  },
   '47763': {
     selector: 7222032299962346917n,
     name: 'neox-mainnet',
@@ -1349,6 +1355,12 @@ const selectors: Selectors = {
     network_type: 'MAINNET',
     family: 'EVM',
   },
+  '202601': {
+    selector: 1091131740251125869n,
+    name: 'ethereum-testnet-sepolia-ronin-1',
+    network_type: 'TESTNET',
+    family: 'EVM',
+  },
   '421613': {
     selector: 6101244977088475029n,
     name: 'ethereum-testnet-goerli-arbitrum-1',

package/src/shared/bcs-codecs.ts

@@ -0,0 +1,132 @@
+/**
+ * BCS (Binary Canonical Serialization) codecs for Move-based chains (Aptos, Sui).
+ * These chains share similar BCS encoding and 32-byte address formats.
+ */
+import { bcs } from '@mysten/bcs'
+import {
+  type BigNumberish,
+  type BytesLike,
+  concat,
+  dataLength,
+  dataSlice,
+  getBytes,
+  hexlify,
+  toBeHex,
+  zeroPadBytes,
+  zeroPadValue,
+} from 'ethers'
+
+import { CCIPDataFormatUnsupportedError } from '../errors/index.ts'
+import {
+  type EVMExtraArgsV2,
+  type SVMExtraArgsV1,
+  EVMExtraArgsV2Tag,
+  SVMExtraArgsV1Tag,
+} from '../extra-args.ts'
+import { ChainFamily } from '../types.ts'
+import { decodeAddress, getDataBytes } from '../utils.ts'
+
+/**
+ * BCS codec for decoding EVM extra args on Move chains (Aptos/Sui).
+ * Used when receiving cross-chain messages from EVM source chains.
+ */
+export const BcsEVMExtraArgsV2Codec = bcs.struct('EVMExtraArgsV2', {
+  gasLimit: bcs.u256(),
+  allowOutOfOrderExecution: bcs.bool(),
+})
+
+/**
+ * BCS codec for decoding SVM (Solana) extra args on Move chains (Aptos/Sui).
+ * Used when receiving cross-chain messages from Solana source chains.
+ */
+export const BcsSVMExtraArgsV1Codec = bcs.struct('SVMExtraArgsV1', {
+  computeUnits: bcs.u32(),
+  accountIsWritableBitmap: bcs.u64(),
+  allowOutOfOrderExecution: bcs.bool(),
+  tokenReceiver: bcs.vector(bcs.u8()),
+  accounts: bcs.vector(bcs.vector(bcs.u8())),
+})
+
+/**
+ * Decodes extra arguments from Move-based chain CCIP messages.
+ * Works for both Aptos and Sui since they share the same BCS encoding.
+ * @param extraArgs - Encoded extra arguments bytes.
+ * @returns Decoded extra arguments or undefined if unknown format.
+ */
+export function decodeMoveExtraArgs(
+  extraArgs: BytesLike,
+):
+  | (EVMExtraArgsV2 & { _tag: 'EVMExtraArgsV2' })
+  | (SVMExtraArgsV1 & { _tag: 'SVMExtraArgsV1' })
+  | undefined {
+  const data = getDataBytes(extraArgs),
+    tag = dataSlice(data, 0, 4)
+  switch (tag) {
+    case EVMExtraArgsV2Tag: {
+      const parsed = BcsEVMExtraArgsV2Codec.parse(getBytes(dataSlice(data, 4)))
+      // Move serialization of EVMExtraArgsV2: 37 bytes total: 4 tag + 32 LE gasLimit + 1 allowOOOE
+      return {
+        _tag: 'EVMExtraArgsV2',
+        ...parsed,
+        gasLimit: BigInt(parsed.gasLimit),
+      }
+    }
+    case SVMExtraArgsV1Tag: {
+      const parsed = BcsSVMExtraArgsV1Codec.parse(getBytes(dataSlice(data, 4)))
+      // Move serialization of SVMExtraArgsV1: 13 bytes total: 4 tag + 8 LE computeUnits
+      return {
+        _tag: 'SVMExtraArgsV1',
+        ...parsed,
+        computeUnits: BigInt(parsed.computeUnits),
+        accountIsWritableBitmap: BigInt(parsed.accountIsWritableBitmap),
+        tokenReceiver: decodeAddress(new Uint8Array(parsed.tokenReceiver), ChainFamily.Solana),
+        accounts: parsed.accounts.map((account) =>
+          decodeAddress(new Uint8Array(account), ChainFamily.Solana),
+        ),
+      }
+    }
+  }
+}
+
+/**
+ * Converts bytes to a Move-chain address (32-byte zero-padded).
+ * Works for both Aptos and Sui since they share the same address format.
+ * @param bytes - Bytes to convert.
+ * @returns Address as 0x-prefixed hex string, 32 bytes padded.
+ * @throws {@link CCIPDataFormatUnsupportedError} if bytes length exceeds 32
+ */
+export function getMoveAddress(bytes: BytesLike | readonly number[]): string {
+  let suffix = ''
+  if (Array.isArray(bytes)) bytes = new Uint8Array(bytes)
+  if (typeof bytes === 'string' && bytes.startsWith('0x')) {
+    const idx = bytes.indexOf('::')
+    if (idx > 0) {
+      suffix = bytes.slice(idx)
+      bytes = bytes.slice(0, idx)
+    }
+  }
+  bytes = getDataBytes(bytes)
+  if (bytes.length > 32)
+    throw new CCIPDataFormatUnsupportedError(`Move address exceeds 32 bytes: ${hexlify(bytes)}`)
+  return zeroPadValue(bytes, 32) + suffix
+}
+
+/**
+ * Encodes a numeric value as a 32-byte hex string.
+ * Used for BCS encoding on Move chains (Aptos/Sui).
+ * @param value - Numeric value to encode.
+ * @returns 32-byte hex string representation of the value.
+ */
+export const encodeNumber = (value: BigNumberish): string => toBeHex(value, 32)
+
+/**
+ * Encodes dynamic bytes with length prefix for BCS serialization.
+ * Used for BCS encoding on Move chains (Aptos/Sui).
+ * @param value - Bytes to encode.
+ * @returns Encoded bytes with 32-byte aligned padding.
+ */
+export const encodeRawBytes = (value: BytesLike): string =>
+  concat([
+    encodeNumber(dataLength(value)),
+    zeroPadBytes(value, Math.ceil(dataLength(value) / 32) * 32),
+  ])

package/src/shared/constants.ts

@@ -0,0 +1,2 @@
+/** Default gas limit for cross-chain message execution (200,000 units). */
+export const DEFAULT_GAS_LIMIT = 200_000n

package/src/solana/exec.ts

@@ -14,7 +14,7 @@ import BN from 'bn.js'
 import { hexlify } from 'ethers'
 
 import { CCIPSolanaLookupTableNotFoundError } from '../errors/index.ts'
-import { type ExecutionReport, type WithLogger, ChainFamily } from '../types.ts'
+import { type ExecutionInput, type WithLogger, ChainFamily } from '../types.ts'
 import { IDL as CCIP_OFFRAMP_IDL } from './idl/1.6.0/CCIP_OFFRAMP.ts'
 import { encodeSolanaOffchainTokenData } from './offchain.ts'
 import type { CCIPMessage_V1_6_Solana, UnsignedSolanaTx } from './types.ts'
@@ -43,7 +43,7 @@ export async function generateUnsignedExecuteReport(
   ctx: { connection: Connection } & WithLogger,
   payer: PublicKey,
   offramp: PublicKey,
-  execReport: ExecutionReport<CCIPMessage_V1_6_Solana>,
+  execReport: ExecutionInput<CCIPMessage_V1_6_Solana>,
   opts?: { forceLookupTable?: boolean; forceBuffer?: boolean; clearLeftoverAccounts?: boolean },
 ): Promise<UnsignedSolanaTx> {
   const { connection, logger = console } = ctx
@@ -274,7 +274,7 @@ async function getManuallyExecuteInputs({
 }: {
   payer: PublicKey
   offramp: Program<typeof CCIP_OFFRAMP_IDL>
-  execReport: ExecutionReport<CCIPMessage_V1_6_Solana>
+  execReport: ExecutionInput<CCIPMessage_V1_6_Solana>
   bufferId?: Buffer
 } & WithLogger) {
   const executionReport = prepareExecutionReport(execReport)
@@ -346,7 +346,7 @@ function prepareExecutionReport({
   message,
   offchainTokenData,
   proofs,
-}: ExecutionReport<CCIPMessage_V1_6_Solana>): IdlTypes<
+}: ExecutionInput<CCIPMessage_V1_6_Solana>): IdlTypes<
   typeof CCIP_OFFRAMP_IDL
 >['ExecutionReportSingleChain'] {
   return {