@chainlink/ccip-sdk 0.96.0 → 1.0.0

package/src/evm/logs.ts

@@ -183,7 +183,7 @@ async function getFallbackArchiveLogs(
  *   - If undefined (default): paginate main provider only by filter.page
  *   - If false: first try whole range with main provider, then fallback to archive provider
  *   - If true: don't paginate (throw if can't fetch wide range from either provider)
- * @param ctx - Context object containing provider, logger and destry$ notify promise
+ * @param ctx - Context object containing provider, logger and destroy$ notify promise
  * @returns Async iterator of logs.
  */
 export async function* getEvmLogs(

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

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

package/src/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
 }