@chainlink/ccip-sdk 0.0.0 → 0.90.0

package/src/evm/messages.ts

@@ -0,0 +1,73 @@
+import type { AbiParametersToPrimitiveTypes, ExtractAbiEvent } from 'abitype'
+import type { Addressable, Result } from 'ethers'
+
+import type { EVMExtraArgsV2 } from '../extra-args.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 { defaultAbiCoder } from './const.ts'
+
+// addresses often come as `string | Addressable`, this type cleans them up to just `string`
+export type CleanAddressable<T> = T extends string | Addressable
+  ? string
+  : T extends Record<string, unknown>
+    ? { [K in keyof T]: CleanAddressable<T[K]> }
+    : T extends readonly unknown[]
+      ? readonly CleanAddressable<T[number]>[]
+      : T
+
+// v1.2-v1.5 Message ()
+type EVM2AnyMessageRequested = CleanAddressable<
+  AbiParametersToPrimitiveTypes<
+    ExtractAbiEvent<typeof EVM2EVMOnRamp_1_5_ABI, 'CCIPSendRequested'>['inputs']
+  >[0]
+>
+
+// v1.6+ Message Base (all other dests share this intersection)
+export type CCIPMessage_V1_6 = MergeArrayElements<
+  CleanAddressable<
+    AbiParametersToPrimitiveTypes<
+      ExtractAbiEvent<typeof OnRamp_1_6_ABI, 'CCIPMessageSent'>['inputs']
+    >[2]
+  >,
+  { tokenAmounts: readonly SourceTokenData[] }
+>
+
+export type CCIPMessage_V1_5_EVM = MergeArrayElements<
+  EVM2AnyMessageRequested,
+  {
+    header: Omit<CCIPMessage_V1_6['header'], 'destChainSelector'>
+    tokenAmounts: readonly SourceTokenData[]
+  }
+>
+
+export type CCIPMessage_V1_2_EVM = EVM2AnyMessageRequested & {
+  header: Omit<CCIPMessage_V1_6['header'], 'destChainSelector'>
+}
+
+// v1.6 EVM specialization, extends CCIPMessage_V1_6, plus EVMExtraArgsV2 and tokenAmounts.*.destGasAmount
+export type CCIPMessage_V1_6_EVM = CCIPMessage_V1_6 & EVMExtraArgsV2
+
+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
+
+const SourceTokenData =
+  'tuple(bytes sourcePoolAddress, bytes destTokenAddress, bytes extraData, uint64 destGasAmount)'
+export type SourceTokenData = {
+  sourcePoolAddress: string
+  destTokenAddress: string
+  extraData: string
+  destGasAmount: bigint
+}
+
+/**
+ * parse <=v1.5 `message.sourceTokenData`;
+ * v1.6+ already contains this in `message.tokenAmounts`
+ */
+export function parseSourceTokenData(data: string): SourceTokenData {
+  const decoded = defaultAbiCoder.decode([SourceTokenData], data)
+  return (decoded[0] as Result).toObject() as SourceTokenData
+}

package/src/evm/offchain.ts

@@ -0,0 +1,189 @@
+import { type Addressable, type Log, EventFragment } from 'ethers'
+
+import { getLbtcAttestation, getUsdcAttestation } from '../offchain.ts'
+import type { CCIPMessage, CCIPRequest, OffchainTokenData } 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'>
+  },
+): Promise<OffchainTokenData[]> {
+  const { isTestnet } = networkInfo(request.message.header.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,
+    isTestnet,
+  )
+  let lbtcTokenData: OffchainTokenData[] = []
+  try {
+    let tokenAmounts: readonly SourceTokenData[]
+    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[], isTestnet)
+  } 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
+}
+
+export function encodeEVMOffchainTokenData(data: OffchainTokenData): string {
+  if (data?._tag === 'usdc') {
+    return defaultAbiCoder.encode(['tuple(bytes message, bytes attestation)'], [data])
+  } else if (data?._tag === 'lbtc') {
+    return data.attestation as 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 isTestnet - use testnet CCTP API endpoint
+ * @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'>[],
+  isTestnet: boolean,
+): 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 ||
+      !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, isTestnet)
+        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
+        console.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 SourceTokenData[],
+  allLogsInRequest: readonly Pick<Log, 'topics' | 'address' | 'data'>[],
+  isTestnet: boolean,
+): 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, isTestnet)) }
+        } catch (err) {
+          console.warn(`❌ EVM LBTC: Failed to fetch attestation for message:`, extraData, err)
+        }
+      }
+    }),
+  )
+}

package/src/execution.ts

@@ -0,0 +1,131 @@
+import moize from 'moize'
+
+import type { Chain, ChainStatic } from './chain.ts'
+import { Tree, getLeafHasher, proofFlagsToBits } from './hasher/index.ts'
+import {
+  type CCIPExecution,
+  type CCIPMessage,
+  type CCIPVersion,
+  type CommitReport,
+  type ExecutionReport,
+  type Lane,
+  ExecutionState,
+} from './types.ts'
+
+/**
+ * Pure/sync function to calculate/generate OffRamp.executeManually report for messageIds
+ *
+ * @param messagesInBatch - Array containing all messages in batch, ordered
+ * @param lane - Arguments for leafeHasher (lane info)
+ * @param messageIds - list of messages (from batch) to prove for manual execution
+ * @param merkleRoot - Optional merkleRoot of the CommitReport, for validation
+ * @returns ManualExec report arguments
+ **/
+export function calculateManualExecProof<V extends CCIPVersion = CCIPVersion>(
+  messagesInBatch: readonly CCIPMessage<V>[],
+  lane: Lane<V>,
+  messageId: string,
+  merkleRoot?: string,
+): Omit<ExecutionReport, 'offchainTokenData' | 'message'> {
+  const hasher = getLeafHasher(lane)
+
+  const msgIdx = messagesInBatch.findIndex((message) => message.header.messageId === messageId)
+  if (msgIdx < 0) {
+    throw new Error(
+      `Could not find ${messageId} in batch seqNums=[${Number(messagesInBatch[0].header.sequenceNumber)}..${Number(messagesInBatch[messagesInBatch.length - 1].header.sequenceNumber)}]`,
+    )
+  }
+
+  const leaves = messagesInBatch.map((message) => hasher(message))
+
+  // Create multi-merkle tree
+  const tree = new Tree(leaves)
+  if (merkleRoot && tree.root() !== merkleRoot) {
+    throw new Error(
+      `Merkle root created from send events doesn't match ReportAccepted merkle root: expected=${merkleRoot}, got=${tree.root()}`,
+    )
+  }
+
+  // Generate proof from multi-merkle tree
+  const proof = tree.prove([msgIdx])
+
+  return {
+    proofs: proof.hashes,
+    proofFlagBits: proofFlagsToBits(proof.sourceFlags),
+    merkleRoot: tree.root(),
+  }
+}
+
+export const discoverOffRamp = moize.default(
+  async function discoverOffRamp_(source: Chain, dest: Chain, onRamp: string): Promise<string> {
+    const sourceRouter = await source.getRouterForOnRamp(onRamp, dest.network.chainSelector)
+    const sourceOffRamps = await source.getOffRampsForRouter(
+      sourceRouter,
+      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)
+        if (offRampsOnRamp === onRamp) {
+          console.debug(
+            'discoverOffRamp: found, from',
+            { sourceRouter, sourceOffRamps, destOnRamp, destOffRamps, offRampsOnRamp },
+            '=',
+            offRamp,
+          )
+          return offRamp
+        }
+      }
+    }
+    throw new Error(`No matching offRamp found for "${onRamp}" on "${dest.network.name}"`)
+  },
+  {
+    transformArgs: ([source, dest, onRamp]) => [
+      (source as Chain).network.chainSelector,
+      (dest as Chain).network.chainSelector,
+      onRamp as string,
+    ],
+  },
+)
+
+/**
+ * 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
+ * 2 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 requests - CCIP requests to search executions for
+ * @param hints.fromBlock - A block from where to start paging forward;
+ *  otherwise, page backwards and completes on first (most recent) receipt
+ * @param hints.page - getLogs pagination range param
+ * @param hints.commit - Special param to help narrow down search on suppported chains (e.g. Solana)
+ **/
+export async function* fetchExecutionReceipts(
+  dest: Chain,
+  offRamp: string,
+  messageIds: Set<string>,
+  hints?: { startBlock?: number; startTime?: number; page?: number; commit?: CommitReport },
+): AsyncGenerator<CCIPExecution> {
+  const onlyLast = !hints?.startBlock && !hints?.startTime // backwards
+  for await (const log of dest.getLogs({
+    ...hints,
+    address: offRamp,
+    topics: ['ExecutionStateChanged'],
+  })) {
+    const receipt = (dest.constructor as ChainStatic).decodeReceipt(log)
+    if (!receipt || !messageIds.has(receipt.messageId)) continue
+    if (onlyLast || receipt.state === ExecutionState.Success) messageIds.delete(receipt.messageId)
+
+    const timestamp = await dest.getBlockTimestamp(log.blockNumber)
+    yield { receipt, log, timestamp }
+    if (!messageIds.size) break
+  }
+}

package/src/extra-args.ts

@@ -0,0 +1,71 @@
+import { type BytesLike, id } from 'ethers'
+
+import { ChainFamily } from './chain.ts'
+import { supportedChains } from './supported-chains.ts'
+
+export const EVMExtraArgsV1Tag = id('CCIP EVMExtraArgsV1').substring(0, 10) as '0x97a657c9'
+export const EVMExtraArgsV2Tag = id('CCIP EVMExtraArgsV2').substring(0, 10) as '0x181dcf10'
+export const SVMExtraArgsV1Tag = id('CCIP SVMExtraArgsV1').substring(0, 10) as '0x1f3b3aba'
+export const SuiExtraArgsV1Tag = id('CCIP SuiExtraArgsV1').substring(0, 10) as '0x21ea4ca9'
+
+export type EVMExtraArgsV1 = {
+  gasLimit: bigint
+}
+// aka GenericExtraArgsV2
+export type EVMExtraArgsV2 = EVMExtraArgsV1 & {
+  allowOutOfOrderExecution: boolean
+}
+export type SVMExtraArgsV1 = {
+  computeUnits: bigint
+  accountIsWritableBitmap: bigint
+  allowOutOfOrderExecution: boolean
+  tokenReceiver: string
+  accounts: string[]
+}
+export type SuiExtraArgsV1 = EVMExtraArgsV2 & {
+  tokenReceiver: string
+  receiverObjectIds: string[]
+}
+
+export type ExtraArgs = EVMExtraArgsV1 | EVMExtraArgsV2 | SVMExtraArgsV1 | SuiExtraArgsV1
+
+/**
+ * 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 targetting EVM
+ **/
+export function encodeExtraArgs(args: ExtraArgs, from: ChainFamily = ChainFamily.EVM): string {
+  const chain = supportedChains[from]
+  if (!chain) throw new Error(`Unsupported chain family: ${from}`)
+  return chain.encodeExtraArgs(args)
+}
+
+/**
+ * Parses extra arguments from CCIP messages
+ * @param data - extra arguments bytearray data
+ * @returns extra arguments object if found
+ **/
+export function decodeExtraArgs(
+  data: BytesLike,
+  from?: ChainFamily,
+):
+  | (EVMExtraArgsV1 & { _tag: 'EVMExtraArgsV1' })
+  | (EVMExtraArgsV2 & { _tag: 'EVMExtraArgsV2' })
+  | (SVMExtraArgsV1 & { _tag: 'SVMExtraArgsV1' })
+  | (SuiExtraArgsV1 & { _tag: 'SuiExtraArgsV1' })
+  | undefined {
+  if (!data || data === '') return
+  let chains
+  if (from) {
+    const chain = supportedChains[from]
+    if (!chain) throw new Error(`Unsupported chain family: ${from}`)
+    chains = [chain]
+  } else {
+    chains = Object.values(supportedChains)
+  }
+  for (const chain of chains) {
+    const decoded = chain.decodeExtraArgs(data)
+    if (decoded) return decoded
+  }
+  throw new Error(`Could not parse extraArgs from "${from}"`)
+}

package/src/gas.ts

@@ -0,0 +1,135 @@
+import {
+  type BytesLike,
+  Contract,
+  FunctionFragment,
+  concat,
+  formatUnits,
+  getNumber,
+  hexlify,
+  randomBytes,
+  solidityPackedKeccak256,
+  toBeHex,
+  zeroPadValue,
+} from 'ethers'
+import type { TypedContract } from 'ethers-abitype'
+
+import type { Chain } from './chain.ts'
+import TokenABI from './evm/abi/BurnMintERC677Token.ts'
+import RouterABI from './evm/abi/Router.ts'
+import { defaultAbiCoder } from './evm/const.ts'
+import type { EVMChain } from './evm/index.ts'
+import { discoverOffRamp } from './execution.ts'
+import type { Lane } from './types.ts'
+
+const BALANCES_SLOT = 0
+const ccipReceive = FunctionFragment.from({
+  type: 'function',
+  name: 'ccipReceive',
+  stateMutability: 'nonpayable',
+  inputs: RouterABI.find((v) => v.type === 'function' && v.name === 'routeMessage')!.inputs.slice(
+    0,
+    1,
+  ),
+  outputs: [],
+})
+type Any2EVMMessage = Parameters<TypedContract<typeof RouterABI>['routeMessage']>[0]
+
+/**
+ * Estimate CCIP gasLimit needed to execute a request on a contract receiver
+ *
+ * @param dest - Provider for the destination chain
+ * @param request - CCIP request info
+ * @param request.lane - Lane info
+ * @param request.message - Message info
+ * @returns estimated gasLimit as bigint
+ **/
+export async function estimateExecGasForRequest(
+  source: Chain,
+  dest: EVMChain,
+  request: {
+    lane: Lane
+    message: {
+      sender: string
+      receiver: string
+      data: BytesLike
+      tokenAmounts: readonly {
+        sourcePoolAddress: string
+        destTokenAddress: string
+        amount: bigint
+      }[]
+    }
+  },
+) {
+  const offRamp = await discoverOffRamp(source, dest, request.lane.onRamp)
+  const destRouter = await dest.getRouterForOffRamp(offRamp, request.lane.sourceChainSelector)
+
+  const destTokenAmounts = await Promise.all(
+    request.message.tokenAmounts.map(async (ta) => {
+      if (!('destTokenAddress' in ta)) throw new Error('legacy <1.5 tokenPools not supported')
+      const [{ decimals: sourceDecimals }, { decimals: destDecimals }] = await Promise.all([
+        source
+          .getTokenForTokenPool(ta.sourcePoolAddress)
+          .then((token) => source.getTokenInfo(token)),
+        dest.getTokenInfo(ta.destTokenAddress),
+      ])
+      const destAmount =
+        (ta.amount * 10n ** BigInt(destDecimals - sourceDecimals + 36)) / 10n ** 36n
+      if (destAmount === 0n)
+        throw new Error(
+          `not enough decimals=${destDecimals} for token=${ta.destTokenAddress} on dest=${dest.network.name} to express ${formatUnits(ta.amount, sourceDecimals)}`,
+        )
+      return { token: ta.destTokenAddress, amount: destAmount }
+    }),
+  )
+
+  const message: Any2EVMMessage = {
+    messageId: hexlify(randomBytes(32)),
+    sender: zeroPadValue(request.message.sender, 32),
+    data: hexlify(request.message.data),
+    sourceChainSelector: request.lane.sourceChainSelector,
+    destTokenAmounts,
+  }
+
+  // we need to override the state, increasing receiver's balance for each token, to simulate the
+  // state after tokens were transferred by the offRamp just before calling `ccipReceive`
+  const destAmounts: Record<string, bigint> = {}
+  const stateOverrides: Record<string, { stateDiff: Record<string, string> }> = {}
+  for (const { token, amount } of destTokenAmounts) {
+    if (!(token in destAmounts)) {
+      const tokenContract = new Contract(token, TokenABI, dest) as unknown as TypedContract<
+        typeof TokenABI
+      >
+      const currentBalance = await tokenContract.balanceOf(request.message.receiver)
+      destAmounts[token] = currentBalance
+    }
+    destAmounts[token] += amount
+    stateOverrides[token] = {
+      stateDiff: {
+        [solidityPackedKeccak256(
+          ['uint256', 'uint256'],
+          [request.message.receiver, BALANCES_SLOT],
+        )]: toBeHex(destAmounts[token], 32),
+      },
+    }
+  }
+
+  const calldata = concat([
+    ccipReceive.selector,
+    defaultAbiCoder.encode(ccipReceive.inputs, [message]),
+  ])
+
+  return (
+    getNumber(
+      (await dest.provider.send('eth_estimateGas', [
+        {
+          from: destRouter,
+          to: request.message.receiver,
+          data: calldata,
+        },
+        'latest',
+        ...(Object.keys(stateOverrides).length ? [stateOverrides] : []),
+      ])) as string,
+    ) -
+    (21_000 - 700) // 21k is the base gas cost for a transaction, 700 is the gas cost of the call
+  )
+}

package/src/hasher/common.ts

@@ -0,0 +1,23 @@
+import { concat, hexlify, keccak256, toBeHex } from 'ethers'
+
+import type { CCIPMessage, CCIPVersion } from '../types.ts'
+
+export type LeafHasher<V extends CCIPVersion = CCIPVersion> = (message: CCIPMessage<V>) => string
+
+const INTERNAL_DOMAIN_SEPARATOR = toBeHex(1, 32)
+export const LEAF_DOMAIN_SEPARATOR = '0x00'
+export const ZERO_HASH = hexlify(new Uint8Array(32).fill(0xff))
+
+/**
+ * Computes the Keccak-256 hash of the concatenation of two hash values.
+ * @param a The first hash as a Hash type.
+ * @param b The second hash as a Hash type.
+ * @returns The Keccak-256 hash result as a Hash type.
+ */
+export function hashInternal(a: string, b: string): string {
+  if (a > b) {
+    ;[a, b] = [b, a]
+  }
+  const combinedData = concat([INTERNAL_DOMAIN_SEPARATOR, a, b])
+  return keccak256(combinedData)
+}

package/src/hasher/hasher.ts

@@ -0,0 +1,12 @@
+import { supportedChains } from '../supported-chains.ts'
+import type { CCIPVersion, Lane } from '../types.ts'
+import { networkInfo } from '../utils.ts'
+import type { LeafHasher } from './common.ts'
+
+// Factory function that returns the right encoder based on the version of the lane
+export function getLeafHasher<V extends CCIPVersion = CCIPVersion>(lane: Lane<V>): LeafHasher<V> {
+  const destFamily = networkInfo(lane.destChainSelector).family
+  const chain = supportedChains[destFamily]
+  if (!chain) throw new Error(`Unsupported chain family: ${destFamily}`)
+  return chain.getDestLeafHasher(lane) as LeafHasher<V>
+}

package/src/hasher/index.ts

@@ -0,0 +1,3 @@
+export { type LeafHasher, ZERO_HASH, hashInternal } from './common.ts'
+export { MAX_NUMBER_TREE_LEAVES, Tree, proofFlagsToBits, verifyComputeRoot } from './merklemulti.ts'
+export { getLeafHasher } from './hasher.ts'