@chainlink/ccip-sdk 0.90.2 → 0.91.0

package/src/chain.ts

@@ -1,9 +1,9 @@
-import util from 'util'
-
 import type { BytesLike } from 'ethers'
+import type { PickDeep } from 'type-fest'
 
+import type { UnsignedAptosTx } from './aptos/types.ts'
 import { fetchCommitReport } from './commits.ts'
-import { fetchExecutionReceipts } from './execution.ts'
+import type { UnsignedEVMTx } from './evm/index.ts'
 import type {
   EVMExtraArgsV1,
   EVMExtraArgsV2,
@@ -12,76 +12,120 @@ import type {
   SuiExtraArgsV1,
 } from './extra-args.ts'
 import type { LeafHasher } from './hasher/common.ts'
-import type {
-  AnyMessage,
-  CCIPCommit,
-  CCIPExecution,
-  CCIPMessage,
-  CCIPRequest,
-  CommitReport,
-  ExecutionReceipt,
-  ExecutionReport,
-  Lane,
-  Log_,
-  NetworkInfo,
-  OffchainTokenData,
+import type { UnsignedSolanaTx } from './solana/types.ts'
+import {
+  type AnyMessage,
+  type CCIPCommit,
+  type CCIPExecution,
+  type CCIPMessage,
+  type CCIPRequest,
+  type ChainFamily,
+  type ChainTransaction,
+  type CommitReport,
+  type ExecutionReceipt,
+  type ExecutionReport,
+  type Lane,
+  type Log_,
+  type Logger,
+  type NetworkInfo,
+  type OffchainTokenData,
+  type WithLogger,
+  ExecutionState,
 } from './types.ts'
+import { util } from './utils.ts'
 
-export const ChainFamily = {
-  EVM: 'evm',
-  Solana: 'solana',
-  Aptos: 'aptos',
-  Sui: 'sui',
-} as const
-export type ChainFamily = (typeof ChainFamily)[keyof typeof ChainFamily]
-
+/**
+ * Filter options for getLogs queries across chains.
+ */
 export type LogFilter = {
+  /** Starting block number (inclusive). */
   startBlock?: number
+  /** Starting Unix timestamp (inclusive). */
   startTime?: number
+  /** Ending block number (inclusive). */
   endBlock?: number
+  /** Optional hint signature for end of iteration. */
   endBefore?: string
+  /** Contract address to filter logs by. */
   address?: string
-  topics?: string[] | string[][]
+  /** Topics to filter logs by. */
+  topics?: (string | string[] | null)[]
+  /** Page size for pagination. */
   page?: number
 }
 
-export type ChainTransaction = {
-  chain: Chain
-  hash: string
-  logs: readonly Log_[]
-  blockNumber: number
-  timestamp: number
-  from: string
-  error?: unknown
-}
-
+/**
+ * Token metadata information.
+ */
 export type TokenInfo = {
+  /** Token symbol (e.g., "LINK"). */
   readonly symbol: string
+  /** Number of decimals for the token. */
   readonly decimals: number
+  /** Optional human-readable token name. */
   readonly name?: string
 }
 
+/**
+ * Rate limiter state for token pool configurations.
+ * Null if rate limiting is disabled.
+ */
 export type RateLimiterState = {
+  /** Current token balance in the rate limiter bucket. */
   tokens: bigint
+  /** Maximum capacity of the rate limiter bucket. */
   capacity: bigint
+  /** Rate at which tokens are replenished. */
   rate: bigint
 } | null
 
+/**
+ * Remote token pool configuration for a specific chain.
+ */
 export type TokenPoolRemote = {
+  /** Address of the remote token on the destination chain. */
   remoteToken: string
+  /** Addresses of remote token pools. */
   remotePools: string[]
+  /** Inbound rate limiter state for tokens coming into this chain. */
   inboundRateLimiterState: RateLimiterState
+  /** Outbound rate limiter state for tokens leaving this chain. */
   outboundRateLimiterState: RateLimiterState
 }
 
+/**
+ * Maps chain family to respective unsigned transaction type.
+ */
+export type UnsignedTx = {
+  [ChainFamily.EVM]: UnsignedEVMTx
+  [ChainFamily.Solana]: UnsignedSolanaTx
+  [ChainFamily.Aptos]: UnsignedAptosTx
+  [ChainFamily.Sui]: never // TODO
+}
+
 /**
  * Works like an interface for a base Chain class, but provides implementation (which can be
  * specialized) for some basic methods
  */
 export abstract class Chain<F extends ChainFamily = ChainFamily> {
-  abstract readonly network: NetworkInfo<F>
-  abstract destroy?(): Promise<void>
+  readonly network: NetworkInfo<F>
+  logger: Logger
+
+  /**
+   * Base constructor for Chain class.
+   * @param network - NetworkInfo object for the Chain instance
+   */
+  constructor(network: NetworkInfo, { logger = console }: WithLogger = {}) {
+    if (network.family !== (this.constructor as ChainStatic).family)
+      throw new Error(`Invalid network family for ${this.constructor.name}: ${network.family}`)
+    this.network = network as NetworkInfo<F>
+    this.logger = logger
+  }
 
+  /** Cleanup method to release resources (e.g., close connections). */
+  destroy?(): void | Promise<void>
+
+  /** Custom inspector for Node.js util.inspect. */
   [util.inspect.custom]() {
     return `${this.constructor.name} { ${this.network.name} }`
   }
@@ -100,33 +144,69 @@ export abstract class Chain<F extends ChainFamily = ChainFamily> {
   abstract getTransaction(hash: string): Promise<ChainTransaction>
   /**
    * An async generator that yields logs based on the provided options.
-   * @param opts - options object
-   * @param opts.startBlock - if provided, fetch and generate logs forward starting from this block;
-   *   otherwise, returns logs backwards in time from endBlock;
-   *   optionally, startTime may be provided to fetch logs forward starting from this time;
-   * @param opts.endBlock - if omitted, use latest block
-   * @param opts.endBefore - optional hint signature for end of iteration, instead of endBlock
-   * @param opts.address - if provided, fetch logs for this address only (may be required in some
-   *   networks/implementations)
-   * @param opts.topics - if provided, fetch logs for these topics only;
-   *   if string[], it's assumed to be a list of topic0s (i.e. string[] or string[][0], event_ids);
-   *   some networks/implementations may not be able to filter topics other than topic0s, so one may
-   *   want to assume those are optimization hints, instead of hard filters, and verify results
-   * @param opts.page - if provided, try to use this page/range for batches
-   * @returns an async iterable iterator of logs
+   * @param opts - Options object containing:
+   *   - `startBlock`: if provided, fetch and generate logs forward starting from this block;
+   *     otherwise, returns logs backwards in time from endBlock;
+   *     optionally, startTime may be provided to fetch logs forward starting from this time
+   *   - `endBlock`: if omitted, use latest block
+   *   - `endBefore`: optional hint signature for end of iteration, instead of endBlock
+   *   - `address`: if provided, fetch logs for this address only (may be required in some
+   *     networks/implementations)
+   *   - `topics`: if provided, fetch logs for these topics only;
+   *     if string[], it's assumed to be a list of topic0s (i.e. string[] or string[][0], event_ids);
+   *     some networks/implementations may not be able to filter topics other than topic0s, so one may
+   *     want to assume those are optimization hints, instead of hard filters, and verify results
+   *   - `page`: if provided, try to use this page/range for batches
+   * @returns An async iterable iterator of logs.
    */
   abstract getLogs(opts: LogFilter): AsyncIterableIterator<Log_>
+
   /**
-   * Fetch the typeAndVersion tag of a given CCIP contract
+   * Fetch all CCIP requests in a transaction
+   * @param tx - ChainTransaction or txHash to fetch requests from
+   * @returns CCIP messages in the transaction (at least one)
+   **/
+  abstract fetchRequestsInTx(tx: string | ChainTransaction): Promise<CCIPRequest[]>
+
+  /**
+   * Scan for a CCIP request by message ID
+   * @param messageId - message ID to fetch request for
+   * @param onRamp - address may be required in some implementations, and throw if missing
+   * @returns CCIPRequest
+   **/
+  fetchRequestById?(
+    messageId: string,
+    onRamp?: string,
+    opts?: { page?: number },
+  ): Promise<CCIPRequest>
+
+  /**
+   * Fetches all CCIP messages contained in a given commit batch.
+   * @param request - CCIPRequest to fetch batch for.
+   * @param commit - CommitReport range (min, max).
+   * @param opts - Optional parameters (e.g., `page` for pagination width).
+   */
+  abstract fetchAllMessagesInBatch<
+    R extends PickDeep<
+      CCIPRequest,
+      'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.header.sequenceNumber'
+    >,
+  >(
+    request: R,
+    commit: Pick<CommitReport, 'minSeqNr' | 'maxSeqNr'>,
+    opts?: { page?: number },
+  ): Promise<R['message'][]>
+  /**
+   * Fetch typeAndVersion for a given CCIP contract address
    * @param address - CCIP contract address
-   * @returns typeAndVersion tag, validated and split
+   * @returns type - parsed type of the contract, e.g. `OnRamp`
+   * @returns version - parsed version of the contract, e.g. `1.6.0`
+   * @returns typeAndVersion - original (unparsed) typeAndVersion() string
+   * @returns suffix - suffix of the version, if any (e.g. `-dev`)
    */
   abstract typeAndVersion(
     address: string,
-  ): Promise<
-    | [type_: string, version: string, typeAndVersion: string]
-    | [type_: string, version: string, typeAndVersion: string, suffix: string]
-  >
+  ): Promise<[type: string, version: string, typeAndVersion: string, suffix?: string]>
 
   /**
    * Fetch the Router address set in OnRamp config
@@ -173,10 +253,10 @@ export abstract class Chain<F extends ChainFamily = ChainFamily> {
    */
   abstract getOnRampForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string>
   /**
-   * Fetch the CommitStore set in OffRamp config (CCIP<=v1.5)
-   * For CCIP>=v1.6, it should return the offRamp address
-   * @param offRamp - OffRamp contract address
-   * @returns CommitStore address
+   * Fetch the CommitStore set in OffRamp config (CCIP v1.5 and earlier).
+   * For CCIP v1.6 and later, it should return the offRamp address.
+   * @param offRamp - OffRamp contract address.
+   * @returns CommitStore address.
    */
   abstract getCommitStoreForOffRamp(offRamp: string): Promise<string>
   /**
@@ -197,12 +277,6 @@ export abstract class Chain<F extends ChainFamily = ChainFamily> {
    * @param onRamp - Some contract for which we can fetch a TokenAdminRegistry
    */
   abstract getTokenAdminRegistryFor(address: string): Promise<string>
-  /**
-   * Build, derive, load or fetch a wallet for this instance which will be used in any tx send operation
-   * @param opts.wallet - cli or environmental parameters to help pick a wallet
-   * @returns address of fetched (and stored internally) account
-   */
-  abstract getWalletAddress(opts?: { wallet?: unknown }): Promise<string>
   /**
    * Fetch the current fee for a given intended message
    * @param router - router address on this chain
@@ -211,54 +285,96 @@ export abstract class Chain<F extends ChainFamily = ChainFamily> {
    */
   abstract getFee(router: string, destChainSelector: bigint, message: AnyMessage): Promise<bigint>
   /**
-   * Send a CCIP message through a router using loaded wallet
-   * @param router - router address on this chain
-   * @param destChainSelector - dest network selector
-   * @param message - message to send
-   * @param opts.wallet - cli or environmental parameters to help pick a wallet
-   * @param opts.approveMax - approve the maximum amount of tokens to transfer
+   * Generate unsigned txs for ccipSend'ing a message
+   * @param sender - sender address
+   * @param router - address of the Router contract
+   * @param destChainSelector - chainSelector of destination chain
+   * @param message - AnyMessage to send; if `fee` is not present, it'll be calculated
+   * @param approveMax - if tokens approvals are needed, opt into approving maximum allowance
+   * @returns chain-family specific unsigned txs
+   */
+  abstract generateUnsignedSendMessage(
+    sender: string,
+    router: string,
+    destChainSelector: bigint,
+    message: AnyMessage & { fee?: bigint },
+    opts?: { approveMax?: boolean },
+  ): Promise<UnsignedTx[F]>
+  /**
+   * Send a CCIP message through a router using provided wallet.
+   * @param router - Router address on this chain.
+   * @param destChainSelector - Destination network selector.
+   * @param message - Message to send.
+   * @param opts - Optional parameters:
+   *   - `wallet`: cli or environmental parameters to help pick a wallet
+   *   - `approveMax`: approve the maximum amount of tokens to transfer
    */
   abstract sendMessage(
     router: string,
     destChainSelector: bigint,
-    message: AnyMessage & { fee: bigint },
-    opts?: { wallet?: unknown; approveMax?: boolean },
-  ): Promise<ChainTransaction>
+    message: AnyMessage & { fee?: bigint },
+    opts: { wallet: unknown; approveMax?: boolean },
+  ): Promise<CCIPRequest>
   /**
    * Fetch supported offchain token data for a request from this network
    * @param request - CCIP request, with tx, logs and message
    * @returns array with one offchain token data for each token transfer in request
    */
   abstract fetchOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]>
+  /**
+   * Generate unsigned tx to manuallyExecute a message
+   * @param payer - address which will be used to transmit the report tx
+   * @param offRamp - address of the OffRamp contract
+   * @param execReport - execution report
+   * @param gasLimit - gasLimit or computeUnits limit override for the ccipReceive call
+   * @param tokensGasLimit - For EVM, overrides gasLimit on tokenpPool call
+   * @param forceBuffer - For Solana, send report in chunks to OffRamp, to later execute
+   * @param forceLookupTable - For Solana, create and extend addresses in a lookup table before executing
+   * @returns chain-family specific unsigned txs
+   */
+  abstract generateUnsignedExecuteReport(
+    payer: string,
+    offRamp: string,
+    execReport: ExecutionReport,
+    opts: {
+      gasLimit?: number
+      tokensGasLimit?: number
+      forceBuffer?: boolean
+      forceLookupTable?: boolean
+    },
+  ): Promise<UnsignedTx[F]>
   /**
    * Execute messages in report in an offRamp
    * @param offRamp - offRamp address on this dest chain
    * @param execReport - execution report containing messages to execute, proofs and offchainTokenData
-   * @param opts - general options for execution
-   * @returns transaction hash of the execution
+   * @param opts - general options for execution (see [[generateUnsignedExecuteReport]])
+   * @param wallet - chain-specific wallet or signer instance, to sign transactions
+   * @returns transaction of the execution
    */
   abstract executeReport(
     offRamp: string,
     execReport: ExecutionReport,
-    opts?: Record<string, unknown>,
+    opts: {
+      wallet: unknown
+      gasLimit?: number
+      tokensGasLimit?: number
+      forceBuffer?: boolean
+      forceLookupTable?: boolean
+    },
   ): Promise<ChainTransaction>
 
   /**
    * Look for a CommitReport at dest for given CCIP request
    * May be specialized by some subclasses
    *
-   * @param dest - Destination network provider
-   * @param request - CCIP request info
+   * @param commitStore - Commit store address
+   * @param request - CCIPRequest to get commit info for
    * @param hints - Additional filtering hints
-   * @returns CCIP commit info
+   * @returns CCIPCommit info, or reject if none found
    **/
   async fetchCommitReport(
     commitStore: string,
-    request: {
-      lane: Lane
-      message: { header: { sequenceNumber: bigint } }
-      timestamp?: number
-    },
+    request: PickDeep<CCIPRequest, 'lane' | 'message.header.sequenceNumber' | 'tx.timestamp'>,
     hints?: { startBlock?: number; page?: number },
   ): Promise<CCIPCommit> {
     return fetchCommitReport(this, commitStore, request, hints)
@@ -267,23 +383,39 @@ export abstract class Chain<F extends ChainFamily = ChainFamily> {
   /**
    * Default/generic implementation of fetchExecutionReceipts
    * @param offRamp - Off-ramp address
-   * @param messageIds - Set of message IDs to fetch receipts for
+   * @param request - CCIPRequest to get execution receipts for
+   * @param commit - CCIPCommit info to help narrowing search for executions
    * @param hints - Additional filtering hints
-   * @returns Async generator of CCIP execution receipts
+   * @returns Async generator of CCIPExecution receipts
    */
   async *fetchExecutionReceipts(
     offRamp: string,
-    messageIds: Set<string>,
-    hints?: { startBlock?: number; startTime?: number; page?: number; commit?: CommitReport },
-  ): AsyncGenerator<CCIPExecution> {
-    yield* fetchExecutionReceipts(this, offRamp, messageIds, hints)
+    request: PickDeep<CCIPRequest, 'lane' | 'message.header.messageId' | 'tx.timestamp'>,
+    commit?: CCIPCommit,
+    hints?: { page?: number },
+  ): AsyncIterableIterator<CCIPExecution> {
+    const onlyLast = !commit?.log.blockNumber && !request.tx.timestamp // backwards
+    for await (const log of this.getLogs({
+      startBlock: commit?.log.blockNumber,
+      startTime: request.tx.timestamp,
+      address: offRamp,
+      topics: ['ExecutionStateChanged'],
+      ...hints,
+    })) {
+      const receipt = (this.constructor as ChainStatic).decodeReceipt(log)
+      if (!receipt || receipt.messageId !== request.message.header.messageId) continue
+
+      const timestamp = log.tx?.timestamp ?? (await this.getBlockTimestamp(log.blockNumber))
+      yield { receipt, log, timestamp }
+      if (onlyLast || receipt.state === ExecutionState.Success) break
+    }
   }
 
   /**
-   * List tokens supported by given TokenAdminRegistry contract
-   * @param address - Usually TokenAdminRegistry, but chain may support receiving Router, OnRamp, etc
-   * @param opts.page - Page range, if needed
-   * @retursn array of supported token addresses
+   * List tokens supported by given TokenAdminRegistry contract.
+   * @param address - Usually TokenAdminRegistry, but chain may support receiving Router, OnRamp, etc.
+   * @param opts - Optional parameters (e.g., `page` for pagination range).
+   * @returns Array of supported token addresses.
    */
   abstract getSupportedTokens(address: string, opts?: { page?: number }): Promise<string[]>
 
@@ -312,10 +444,10 @@ export abstract class Chain<F extends ChainFamily = ChainFamily> {
   }>
 
   /**
-   * Get TokenPool remote configurations
-   * @param tokenPool - Token pool address
-   * @param remoteChainSelector - If provided, only return remotes for the specified chain (may error if remote not supported)
-   * @param Record of network *names* and remote configurations (remoteToken, remotePools, rateLimitStates)
+   * Get TokenPool remote configurations.
+   * @param tokenPool - Token pool address.
+   * @param remoteChainSelector - If provided, only return remotes for the specified chain (may error if remote not supported).
+   * @returns Record of network names and remote configurations (remoteToken, remotePools, rateLimitStates).
    */
   abstract getTokenPoolRemotes(
     tokenPool: string,
@@ -323,13 +455,14 @@ export abstract class Chain<F extends ChainFamily = ChainFamily> {
   ): Promise<Record<string, TokenPoolRemote>>
 
   /**
-   * Fetch list and info of supported feeTokens
-   * @param router address on this chain
-   * @returns mapping of token addresses to respective TokenInfo objects
+   * Fetch list and info of supported feeTokens.
+   * @param router - Router address on this chain.
+   * @returns Mapping of token addresses to respective TokenInfo objects.
    */
-  abstract listFeeTokens(router: string): Promise<Record<string, TokenInfo>>
+  abstract getFeeTokens(router: string): Promise<Record<string, TokenInfo>>
 }
 
+/** Static methods and properties available on Chain class constructors. */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 export type ChainStatic<F extends ChainFamily = ChainFamily> = Function & {
   readonly family: F
@@ -338,7 +471,7 @@ export type ChainStatic<F extends ChainFamily = ChainFamily> = Function & {
    * async constructor: builds a Chain from a rpc endpoint url
    * @param url - rpc endpoint url
    */
-  fromUrl(url: string): Promise<Chain<F>>
+  fromUrl(url: string, ctx?: WithLogger): Promise<Chain<F>>
   /**
    * Try to decode a CCIP message *from* a log/event *originated* from this *source* chain,
    * but which may *target* other dest chain families
@@ -384,15 +517,17 @@ export type ChainStatic<F extends ChainFamily = ChainFamily> = Function & {
   /**
    * Create a leaf hasher for this dest chain and lane
    * @param lane - source, dest and onramp lane info
+   * @param ctx - context object containing logger
    * @returns LeafHasher is a function that takes a message and returns a hash of it
    */
-  getDestLeafHasher(lane: Lane): LeafHasher
+  getDestLeafHasher(lane: Lane, ctx?: WithLogger): LeafHasher
   /**
    * Try to parse an error or bytearray generated by this chain family
-   * @param error - catched object, string or bytearray
+   * @param data - Caught object, string or bytearray
    * @returns Ordered record with messages/properties, or undefined if not a recognized error
    */
   parse?(data: unknown): Record<string, unknown> | undefined | null
 }
 
+/** Function type for getting a Chain instance by ID, selector, or name. */
 export type ChainGetter = (idOrSelectorOrName: number | string | bigint) => Promise<Chain>

package/src/commits.ts

@@ -1,5 +1,7 @@
+import type { PickDeep } from 'type-fest'
+
 import type { Chain, ChainStatic } from './chain.ts'
-import { type CCIPCommit, type Lane, CCIPVersion } from './types.ts'
+import { type CCIPCommit, type CCIPRequest, CCIPVersion } from './types.ts'
 
 /**
  * Look for a CommitReport at dest for given CCIPRequest
@@ -7,6 +9,7 @@ import { type CCIPCommit, type Lane, CCIPVersion } from './types.ts'
  * logic in Chain.fetchCommitReport method
  *
  * @param dest - Destination network provider
+ * @param commitStore - Commit store address
  * @param request - CCIP request info
  * @param hints - Additional filtering hints
  * @returns CCIP commit info
@@ -17,12 +20,8 @@ export async function fetchCommitReport(
   {
     lane,
     message: { header },
-    timestamp: requestTimestamp,
-  }: {
-    lane: Lane
-    message: { header: { sequenceNumber: bigint } }
-    timestamp?: number
-  },
+    tx: { timestamp: requestTimestamp },
+  }: PickDeep<CCIPRequest, 'lane' | 'message.header.sequenceNumber' | 'tx.timestamp'>,
   hints?: { startBlock?: number; page?: number },
 ): Promise<CCIPCommit> {
   for await (const log of dest.getLogs({

package/src/evm/const.ts

@@ -46,6 +46,11 @@ export const interfaces = {
   Custom: new Interface(customErrors),
 } as const
 
+/**
+ * Gets all event fragments matching the given event names.
+ * @param events - Event names to match.
+ * @returns Map of topic hash to event fragment.
+ */
 export function getAllFragmentsMatchingEvents(
   events: readonly string[],
 ): Record<`0x${string}`, EventFragment> {

package/src/evm/errors.ts

@@ -12,8 +12,8 @@ import {
 } from 'ethers'
 
 import { defaultAbiCoder, interfaces } from './const.ts'
-import { ChainFamily } from '../chain.ts'
 import { decodeExtraArgs } from '../extra-args.ts'
+import { ChainFamily } from '../types.ts'
 
 /**
  * Get error data from an error object, if possible
@@ -173,6 +173,11 @@ export function recursiveParseError(
   return res
 }
 
+/**
+ * Parses error data and transaction responses to extract human-readable info.
+ * @param data - Raw error data or transaction response.
+ * @returns Parsed error information or undefined.
+ */
 export function parseData(data: unknown): Record<string, unknown> | undefined {
   if (!data) return
   if (isHexString(data)) {

package/src/evm/hasher.ts

@@ -1,13 +1,21 @@
 import { concat, id, keccak256, toBeHex, zeroPadValue } from 'ethers'
+import type { ReadonlyDeep } from 'type-fest'
 
 import { decodeExtraArgs } from '../extra-args.ts'
 import { type LeafHasher, LEAF_DOMAIN_SEPARATOR } from '../hasher/common.ts'
-import type { CCIPMessage, CCIPVersion, DeepReadonly } from '../types.ts'
+import type { CCIPMessage, CCIPVersion, WithLogger } from '../types.ts'
 import { getAddressBytes, getDataBytes, networkInfo } from '../utils.ts'
 import { defaultAbiCoder } from './const.ts'
 
 const METADATA_PREFIX_1_2 = id('EVM2EVMMessageHashV2')
 
+/**
+ * Creates a leaf hasher for v1.2/v1.5 EVM CCIP messages.
+ * @param sourceChainSelector - Source chain selector.
+ * @param destChainSelector - Destination chain selector.
+ * @param onRamp - OnRamp contract address.
+ * @returns Leaf hasher function.
+ */
 export function getV12LeafHasher(
   sourceChainSelector: bigint,
   destChainSelector: bigint,
@@ -80,10 +88,18 @@ export function getV12LeafHasher(
 
 const ANY_2_EVM_MESSAGE_HASH = id('Any2EVMMessageHashV1')
 
+/**
+ * Creates a leaf hasher for v1.6 EVM CCIP messages.
+ * @param sourceChainSelector - Source chain selector.
+ * @param destChainSelector - Destination chain selector.
+ * @param onRamp - OnRamp contract address.
+ * @returns Leaf hasher function.
+ */
 export function getV16LeafHasher(
   sourceChainSelector: bigint,
   destChainSelector: bigint,
   onRamp: string,
+  { logger = console }: WithLogger = {},
 ): LeafHasher<typeof CCIPVersion.V1_6> {
   const metadataInput = concat([
     ANY_2_EVM_MESSAGE_HASH,
@@ -92,8 +108,8 @@ export function getV16LeafHasher(
     keccak256(zeroPadValue(getAddressBytes(onRamp), 32)),
   ])
 
-  return (message: DeepReadonly<CCIPMessage<typeof CCIPVersion.V1_6>>): string => {
-    console.debug('Message', message)
+  return (message: ReadonlyDeep<CCIPMessage<typeof CCIPVersion.V1_6>>): string => {
+    logger.debug('Message', message)
     const parsedArgs = decodeExtraArgs(
       message.extraArgs,
       networkInfo(message.header.sourceChainSelector).family,
@@ -153,7 +169,7 @@ export function getV16LeafHasher(
       ],
     )
 
-    console.debug('v1.6 leafHasher:', {
+    logger.debug('v1.6 leafHasher:', {
       messageId: message.header.messageId,
       encodedTokens,
       fixedSizeValues,