@chainlink/ccip-sdk 0.92.1 → 0.93.0

package/src/evm/index.ts

@@ -7,6 +7,7 @@ import {
   type Signer,
   type TransactionReceipt,
   type TransactionRequest,
+  type TransactionResponse,
   Contract,
   JsonRpcProvider,
   Result,
@@ -28,7 +29,7 @@ import type { TypedContract } from 'ethers-abitype'
 import { memoize } from 'micro-memoize'
 import type { PickDeep, SetRequired } from 'type-fest'
 
-import { type LogFilter, type TokenPoolRemote, Chain } from '../chain.ts'
+import { type ChainContext, type LogFilter, type TokenPoolRemote, Chain } from '../chain.ts'
 import {
   CCIPAddressInvalidEvmError,
   CCIPBlockNotFoundError,
@@ -63,15 +64,12 @@ import {
 import type { LeafHasher } from '../hasher/common.ts'
 import { supportedChains } from '../supported-chains.ts'
 import {
-  type AnyMessage,
-  type CCIPCommit,
   type CCIPExecution,
   type CCIPMessage,
   type CCIPRequest,
   type ChainTransaction,
   type CommitReport,
   type ExecutionReceipt,
-  type ExecutionReport,
   type ExecutionState,
   type Lane,
   type Log_,
@@ -118,11 +116,7 @@ import {
   parseSourceTokenData,
 } from './messages.ts'
 import { encodeEVMOffchainTokenData, fetchEVMOffchainTokenData } from './offchain.ts'
-import {
-  fetchAllMessagesInBatch,
-  fetchCCIPRequestById,
-  fetchCCIPRequestsInTx,
-} from '../requests.ts'
+import { getMessageById, getMessagesInBatch, getMessagesInTx } from '../requests.ts'
 import type { UnsignedEVMTx } from './types.ts'
 export type { UnsignedEVMTx }
 
@@ -159,6 +153,24 @@ function isSigner(wallet: unknown): wallet is Signer {
   )
 }
 
+/**
+ * Submit transaction using best available method.
+ * Try sendTransaction() first (works with browser wallets),
+ * fallback to signTransaction() + broadcastTransaction() if unsupported.
+ */
+async function submitTransaction(
+  wallet: Signer,
+  tx: TransactionRequest,
+  provider: JsonRpcApiProvider,
+): Promise<TransactionResponse> {
+  try {
+    return await wallet.sendTransaction(tx)
+  } catch {
+    const signed = await wallet.signTransaction(tx)
+    return provider.broadcastTransaction(signed)
+  }
+}
+
 /**
  * EVM chain implementation supporting Ethereum-compatible networks.
  */
@@ -177,7 +189,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
    * @param provider - JSON-RPC provider for the EVM network.
    * @param network - Network information for this chain.
    */
-  constructor(provider: JsonRpcApiProvider, network: NetworkInfo, ctx?: WithLogger) {
+  constructor(provider: JsonRpcApiProvider, network: NetworkInfo, ctx?: ChainContext) {
     super(network, ctx)
 
     this.provider = provider
@@ -252,7 +264,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
    * @param ctx - context containing logger.
    * @returns A new EVMChain instance.
    */
-  static async fromProvider(provider: JsonRpcApiProvider, ctx?: WithLogger): Promise<EVMChain> {
+  static async fromProvider(provider: JsonRpcApiProvider, ctx?: ChainContext): Promise<EVMChain> {
     try {
       return new EVMChain(provider, networkInfo(Number((await provider.getNetwork()).chainId)), ctx)
     } catch (err) {
@@ -267,7 +279,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
    * @param ctx - context containing logger.
    * @returns A new EVMChain instance.
    */
-  static async fromUrl(url: string, ctx?: WithLogger): Promise<EVMChain> {
+  static async fromUrl(url: string, ctx?: ChainContext): Promise<EVMChain> {
     return this.fromProvider(await this._getProvider(url), ctx)
   }
 
@@ -300,22 +312,22 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     yield* getEvmLogs(filter, this)
   }
 
-  /** {@inheritDoc Chain.fetchRequestsInTx} */
-  async fetchRequestsInTx(tx: string | ChainTransaction): Promise<CCIPRequest[]> {
-    return fetchCCIPRequestsInTx(this, typeof tx === 'string' ? await this.getTransaction(tx) : tx)
+  /** {@inheritDoc Chain.getMessagesInTx} */
+  async getMessagesInTx(tx: string | ChainTransaction): Promise<CCIPRequest[]> {
+    return getMessagesInTx(this, typeof tx === 'string' ? await this.getTransaction(tx) : tx)
   }
 
-  /** {@inheritDoc Chain.fetchRequestById} */
-  override fetchRequestById(
+  /** {@inheritDoc Chain.getMessageById} */
+  override getMessageById(
     messageId: string,
     onRamp?: string,
     opts?: { page?: number },
   ): Promise<CCIPRequest> {
-    return fetchCCIPRequestById(this, messageId, { address: onRamp, ...opts })
+    return getMessageById(this, messageId, { address: onRamp, ...opts })
   }
 
-  /** {@inheritDoc Chain.fetchAllMessagesInBatch} */
-  async fetchAllMessagesInBatch<
+  /** {@inheritDoc Chain.getMessagesInBatch} */
+  getMessagesInBatch<
     R extends PickDeep<
       CCIPRequest,
       'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.sequenceNumber'
@@ -330,10 +342,10 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
       // specialized getLogs filter for v1.6 CCIPMessageSent events, to filter by dest
       opts_ = {
         ...opts,
-        topics: [[request.log.topics[0]], [toBeHex(request.lane.destChainSelector, 32)]],
+        topics: [[request.log.topics[0]!], [toBeHex(request.lane.destChainSelector, 32)]],
       }
     }
-    return fetchAllMessagesInBatch(this, request, commit, opts_)
+    return getMessagesInBatch(this, request, commit, opts_)
   }
 
   /** {@inheritDoc Chain.typeAndVersion} */
@@ -358,8 +370,9 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     if (!isBytesLike(log.data)) throw new CCIPLogDataInvalidError(log.data)
     let fragments
     if (log.topics?.[0]) {
-      fragments = [requestsFragments[log.topics[0] as `0x${string}`]]
-      if (!fragments[0]) return
+      const f = requestsFragments[log.topics[0] as `0x${string}`]
+      if (!f) return
+      fragments = [f]
     } else {
       fragments = Object.values(requestsFragments)
     }
@@ -369,7 +382,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         // we don't actually use Interface instance here, `decodeEventLog` is mostly static when given a fragment
         const result = interfaces.OnRamp_v1_6.decodeEventLog(fragment, log.data, log.topics)
         message = resultToObject(result) as Record<string, unknown>
-        if (message.message) message = message.message as Record<string, unknown>
+        if (message.message) message = message.message as Record<string, unknown> | undefined
         if (message) break
       } catch (_) {
         // try next fragment
@@ -399,7 +412,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           try {
             tokenAmount = {
               ...parseSourceTokenData(
-                (message as { sourceTokenData: string[] }).sourceTokenData[i],
+                (message as { sourceTokenData: string[] }).sourceTokenData[i]!,
               ),
               ...tokenAmount,
             }
@@ -513,8 +526,9 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     if (!isBytesLike(log.data)) throw new CCIPLogDataInvalidError(log.data)
     let fragments
     if (log.topics?.[0]) {
-      fragments = [receiptsFragments[log.topics[0] as `0x${string}`]]
-      if (!fragments[0]) return
+      const f = receiptsFragments[log.topics[0] as `0x${string}`]
+      if (!f) return
+      fragments = [f]
     } else fragments = Object.values(receiptsFragments)
     for (const fragment of fragments) {
       try {
@@ -579,7 +593,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
    * @param args - Extra arguments to encode.
    * @returns Encoded extra arguments as hex string.
    */
-  static encodeExtraArgs(args: ExtraArgs): string {
+  static encodeExtraArgs(args: ExtraArgs | undefined): string {
     if (!args) return '0x'
     if ('computeUnits' in args) {
       return concat([
@@ -610,9 +624,9 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         ),
       ])
     } else if ('allowOutOfOrderExecution' in args) {
-      if (args.gasLimit == null) args.gasLimit = DEFAULT_GAS_LIMIT
+      if ((args as Partial<typeof args>).gasLimit == null) args.gasLimit = DEFAULT_GAS_LIMIT
       return concat([EVMExtraArgsV2Tag, defaultAbiCoder.encode([EVMExtraArgsV2], [args])])
-    } else if (args.gasLimit != null) {
+    } else if ((args as Partial<typeof args>).gasLimit != null) {
       return concat([EVMExtraArgsV1Tag, defaultAbiCoder.encode([EVMExtraArgsV1], [args])])
     }
     return '0x'
@@ -914,6 +928,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
 
   /**
    * Gets the FeeQuoter contract address for a given Router or Ramp.
+   * @internal
    * @param address - Router or Ramp contract address.
    * @returns FeeQuoter contract address.
    */
@@ -940,13 +955,17 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   }
 
   /** {@inheritDoc Chain.getFee} */
-  async getFee(router_: string, destChainSelector: bigint, message: AnyMessage): Promise<bigint> {
-    const router = new Contract(
-      router_,
+  async getFee({
+    router,
+    destChainSelector,
+    message,
+  }: Parameters<Chain['getFee']>[0]): Promise<bigint> {
+    const contract = new Contract(
+      router,
       interfaces.Router,
       this.provider,
     ) as unknown as TypedContract<typeof Router_ABI>
-    return router.getFee(destChainSelector, {
+    return contract.getFee(destChainSelector, {
       receiver: zeroPadValue(getAddressBytes(message.receiver), 32),
       data: hexlify(message.data),
       tokenAmounts: message.tokenAmounts ?? [],
@@ -956,23 +975,15 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   }
 
   /**
-   * 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
+   * {@inheritDoc Chain.generateUnsignedSendMessage}
    * @returns Array containing 0 or more unsigned token approvals txs (if needed at the time of
    *   generation), followed by a ccipSend TransactionRequest
    */
   async generateUnsignedSendMessage(
-    sender: string,
-    router: string,
-    destChainSelector: bigint,
-    message: AnyMessage & { fee?: bigint },
-    opts?: { approveMax?: boolean },
+    opts: Parameters<Chain['generateUnsignedSendMessage']>[0],
   ): Promise<UnsignedEVMTx> {
-    if (!message.fee) message.fee = await this.getFee(router, destChainSelector, message)
+    const { sender, router, destChainSelector, message } = opts
+    if (!message.fee) message.fee = await this.getFee(opts)
     const feeToken = message.feeToken ?? ZeroAddress
     const receiver = zeroPadValue(getAddressBytes(message.receiver), 32)
     const data = hexlify(message.data)
@@ -998,7 +1009,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           ) as unknown as TypedContract<typeof Token_ABI>
           const allowance = await contract.allowance(sender, router)
           if (allowance >= amount) return
-          const amnt = opts?.approveMax ? 2n ** 256n - 1n : amount
+          const amnt = opts.approveMax ? 2n ** 256n - 1n : amount
           return contract.approve.populateTransaction(router, amnt, { from: sender })
         }),
       )
@@ -1032,25 +1043,14 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   }
 
   /** {@inheritDoc Chain.sendMessage} */
-  async sendMessage(
-    router_: string,
-    destChainSelector: bigint,
-    message: AnyMessage & { fee?: bigint },
-    opts: { wallet: unknown; approveMax?: boolean },
-  ): Promise<CCIPRequest> {
+  async sendMessage(opts: Parameters<Chain['sendMessage']>[0]): Promise<CCIPRequest> {
     const wallet = opts.wallet
     if (!isSigner(wallet)) throw new CCIPWalletInvalidError(wallet)
 
     const sender = await wallet.getAddress()
-    const txs = await this.generateUnsignedSendMessage(
-      sender,
-      router_,
-      destChainSelector,
-      message,
-      opts,
-    )
+    const txs = await this.generateUnsignedSendMessage({ ...opts, sender })
     const approveTxs = txs.transactions.slice(0, txs.transactions.length - 1)
-    let sendTx: TransactionRequest = txs.transactions[txs.transactions.length - 1]
+    let sendTx: TransactionRequest = txs.transactions[txs.transactions.length - 1]!
 
     // approve all tokens (including feeToken, if needed) in parallel
     let nonce = await this.provider.getTransactionCount(sender)
@@ -1059,44 +1059,37 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         tx.nonce = nonce++
         tx = await wallet.populateTransaction(tx)
         tx.from = undefined
-        const signed = await wallet.signTransaction(tx)
-        const response = await this.provider.broadcastTransaction(signed)
+        const response = await submitTransaction(wallet, tx, this.provider)
         this.logger.debug('approve =>', response.hash)
         return response
       }),
     )
-    if (responses.length) await responses[responses.length - 1].wait(1, 60_000) // wait last tx nonce to be mined
+    if (responses.length) await responses[responses.length - 1]!.wait(1, 60_000) // wait last tx nonce to be mined
 
     sendTx.nonce = nonce++
     // sendTx.gasLimit = await this.provider.estimateGas(sendTx)
     sendTx = await wallet.populateTransaction(sendTx)
     sendTx.from = undefined // some signers don't like receiving pre-populated `from`
-    const signed = await wallet.signTransaction(sendTx)
-    const response = await this.provider.broadcastTransaction(signed)
+    const response = await submitTransaction(wallet, sendTx, this.provider)
     this.logger.debug('ccipSend =>', response.hash)
     await response.wait(1, 60_000)
-    return (await this.fetchRequestsInTx(await this.getTransaction(response.hash)))[0]
+    return (await this.getMessagesInTx(await this.getTransaction(response.hash)))[0]!
   }
 
-  /** {@inheritDoc Chain.fetchOffchainTokenData} */
-  fetchOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]> {
+  /** {@inheritDoc Chain.getOffchainTokenData} */
+  getOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]> {
     return fetchEVMOffchainTokenData(request, this)
   }
 
   /**
-   * Generate unsigned tx to manuallyExecute a message
-   * @param _payer - not used in EVM
-   * @param offRamp - address of the OffRamp contract
-   * @param execReport - execution report
-   * @param opts - gas limit overrides for ccipReceive and tokenPool calls options
+   * {@inheritDoc Chain.generateUnsignedExecuteReport}
    * @returns array containing one unsigned `manuallyExecute` TransactionRequest object
    */
-  async generateUnsignedExecuteReport(
-    _payer: string,
-    offRamp: string,
-    execReport: ExecutionReport,
-    opts: { gasLimit?: number; tokensGasLimit?: number },
-  ): Promise<UnsignedEVMTx> {
+  async generateUnsignedExecuteReport({
+    offRamp,
+    execReport,
+    ...opts
+  }: Parameters<Chain['generateUnsignedExecuteReport']>[0]): Promise<UnsignedEVMTx> {
     const [_, version] = await this.typeAndVersion(offRamp)
 
     let manualExecTx
@@ -1109,7 +1102,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           EVM2EVMOffRamp_1_2_ABI,
           this.provider,
         ) as unknown as TypedContract<typeof EVM2EVMOffRamp_1_2_ABI>
-        const gasOverride = BigInt(opts?.gasLimit ?? 0)
+        const gasOverride = BigInt(opts.gasLimit ?? 0)
         manualExecTx = await contract.manuallyExecute.populateTransaction(
           {
             ...execReport,
@@ -1136,9 +1129,9 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           },
           [
             {
-              receiverExecutionGasLimit: BigInt(opts?.gasLimit ?? 0),
+              receiverExecutionGasLimit: BigInt(opts.gasLimit ?? 0),
               tokenGasOverrides: execReport.message.tokenAmounts.map(() =>
-                BigInt(opts?.tokensGasLimit ?? opts?.gasLimit ?? 0),
+                BigInt(opts.tokensGasLimit ?? opts.gasLimit ?? 0),
               ),
             },
           ],
@@ -1189,9 +1182,9 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           [
             [
               {
-                receiverExecutionGasLimit: BigInt(opts?.gasLimit ?? 0),
+                receiverExecutionGasLimit: BigInt(opts.gasLimit ?? 0),
                 tokenGasOverrides: execReport.message.tokenAmounts.map(() =>
-                  BigInt(opts?.tokensGasLimit ?? opts?.gasLimit ?? 0),
+                  BigInt(opts.tokensGasLimit ?? opts.gasLimit ?? 0),
                 ),
               },
             ],
@@ -1206,29 +1199,23 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   }
 
   /** {@inheritDoc Chain.executeReport} */
-  async executeReport(
-    offRamp: string,
-    execReport: ExecutionReport,
-    opts: { wallet: unknown; gasLimit?: number; tokensGasLimit?: number },
-  ) {
+  async executeReport(opts: Parameters<Chain['executeReport']>[0]) {
     const wallet = opts.wallet
     if (!isSigner(wallet)) throw new CCIPWalletInvalidError(wallet)
 
-    const unsignedTxs = await this.generateUnsignedExecuteReport(
-      await wallet.getAddress(),
-      offRamp,
-      execReport,
-      opts,
-    )
-    const unsignedTx = await wallet.populateTransaction(unsignedTxs.transactions[0])
+    const unsignedTxs = await this.generateUnsignedExecuteReport({
+      ...opts,
+      payer: await wallet.getAddress(),
+    })
+    const unsignedTx = await wallet.populateTransaction(unsignedTxs.transactions[0]!)
     unsignedTx.from = undefined // some signers don't like receiving pre-populated `from`
-    const signed = await wallet.signTransaction(unsignedTx)
-    const response = await this.provider.broadcastTransaction(signed)
-    this.logger.debug('ccipSend =>', response.hash)
+    const response = await submitTransaction(wallet, unsignedTx, this.provider)
+    this.logger.debug('manuallyExecute =>', response.hash)
     const receipt = await response.wait(1, 60_000)
     if (!receipt?.hash) throw new CCIPExecTxNotConfirmedError(response.hash)
     if (!receipt.status) throw new CCIPExecTxRevertedError(response.hash)
-    return this.getTransaction(receipt)
+    const tx = await this.getTransaction(receipt)
+    return this.getExecutionReceiptInTx(tx)
   }
 
   /**
@@ -1324,7 +1311,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   ): Promise<Record<string, TokenPoolRemote>> {
     const [_, version] = await this.typeAndVersion(tokenPool)
 
-    let supportedChains: Promise<NetworkInfo[]>
+    let supportedChains: Promise<NetworkInfo[]> | undefined
     if (remoteChainSelector) supportedChains = Promise.resolve([networkInfo(remoteChainSelector)])
 
     let remotePools: Promise<string[][]>
@@ -1383,10 +1370,10 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
               [
                 chain.name,
                 {
-                  remoteToken: decodeAddress(remoteInfo[i][0], chain.family),
-                  remotePools: remotePools[i].map((pool) => decodeAddress(pool, chain.family)),
-                  inboundRateLimiterState: remoteInfo[i][1].isEnabled ? remoteInfo[i][1] : null,
-                  outboundRateLimiterState: remoteInfo[i][2].isEnabled ? remoteInfo[i][2] : null,
+                  remoteToken: decodeAddress(remoteInfo[i]![0], chain.family),
+                  remotePools: remotePools[i]!.map((pool) => decodeAddress(pool, chain.family)),
+                  inboundRateLimiterState: remoteInfo[i]![1].isEnabled ? remoteInfo[i]![1] : null,
+                  outboundRateLimiterState: remoteInfo[i]![2].isEnabled ? remoteInfo[i]![2] : null,
                 },
               ] as const,
           ),
@@ -1399,7 +1386,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     const onRamp = await this._getSomeOnRampFor(router)
     const [_, version] = await this.typeAndVersion(onRamp)
     let tokens
-    let onRampIface: Interface
+    let onRampIface: Interface | undefined
     switch (version) {
       case CCIPVersion.V1_2:
         onRampIface = interfaces.EVM2EVMOnRamp_v1_2
@@ -1447,21 +1434,21 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     )
   }
 
-  /** {@inheritDoc Chain.fetchExecutionReceipts} */
-  override async *fetchExecutionReceipts(
-    offRamp: string,
-    request: PickDeep<CCIPRequest, 'lane' | 'message.messageId' | 'tx.timestamp'>,
-    commit?: CCIPCommit,
-    opts?: Pick<LogFilter, 'page' | 'watch'>,
+  /** {@inheritDoc Chain.getExecutionReceipts} */
+  override async *getExecutionReceipts(
+    opts: Parameters<Chain['getExecutionReceipts']>[0],
   ): AsyncIterableIterator<CCIPExecution> {
-    let opts_: Parameters<EVMChain['getLogs']>[0] | undefined = opts
-    if (request.lane.version < CCIPVersion.V1_6) {
+    const { messageId, sourceChainSelector } = opts
+    let opts_: Parameters<Chain['getExecutionReceipts']>[0] & Parameters<EVMChain['getLogs']>[0] =
+      opts
+    const [, version] = await this.typeAndVersion(opts.offRamp)
+    if (version < CCIPVersion.V1_6) {
       opts_ = {
         ...opts,
         topics: [
           interfaces.EVM2EVMOffRamp_v1_5.getEvent('ExecutionStateChanged')!.topicHash,
           null,
-          request.message.messageId,
+          messageId ?? null,
         ],
         // onlyFallback: false,
       }
@@ -1470,13 +1457,13 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         ...opts,
         topics: [
           interfaces.OffRamp_v1_6.getEvent('ExecutionStateChanged')!.topicHash,
-          toBeHex(request.lane.sourceChainSelector, 32),
+          sourceChainSelector ? toBeHex(sourceChainSelector, 32) : null,
           null,
-          request.message.messageId,
+          messageId ?? null,
         ],
         // onlyFallback: false,
       }
     }
-    yield* super.fetchExecutionReceipts(offRamp, request, commit, opts_)
+    yield* super.getExecutionReceipts(opts_)
   }
 }

package/src/evm/logs.ts

@@ -62,7 +62,7 @@ function anyPromiseMax<T>(
         const currentIndex = index++
         inFlight++
 
-        void promises[currentIndex]()
+        void promises[currentIndex]!()
           .then(resolve)
           .catch((error) => {
             errors[currentIndex] = error
@@ -114,7 +114,7 @@ async function getFallbackArchiveLogs(
   let cancel$ = new Promise<unknown>((resolve) => (cancel = resolve))
   if (destroy$) cancel$ = Promise.race([destroy$, cancel$])
 
-  let winner: string
+  let winner: string | undefined
   const providerLogs$ = getFallbackRpcsList()
     .then((rpcs) => {
       const rpc = rpcs.find(({ chainId: id }) => id === chainId)
@@ -268,7 +268,7 @@ export async function* getEvmLogs(
     logger.debug('evm getLogs:', filter_)
     const logs = await provider.getLogs(filter_)
     if (logs.length)
-      latestLogBlockNumber = Math.max(latestLogBlockNumber, logs[logs.length - 1].blockNumber)
+      latestLogBlockNumber = Math.max(latestLogBlockNumber, logs[logs.length - 1]!.blockNumber)
     if (filter.startBlock == null) logs.reverse()
     yield* logs
   }
@@ -297,7 +297,7 @@ export async function* getEvmLogs(
     logger.debug('evm watch getLogs:', filter_)
     const logs = await provider.getLogs(filter_)
     if (logs.length)
-      latestLogBlockNumber = Math.max(latestLogBlockNumber, logs[logs.length - 1].blockNumber)
+      latestLogBlockNumber = Math.max(latestLogBlockNumber, logs[logs.length - 1]!.blockNumber)
     yield* logs
   }
 }

package/src/evm/offchain.ts

@@ -40,7 +40,7 @@ export async function fetchEVMOffchainTokenData(
   // 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,
+      ({ 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,
@@ -118,8 +118,9 @@ async function getUsdcTokenData(
     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])
+      transferLog?.topics[0] !== TRANSFER_EVENT.topicHash ||
+      !poolLog?.topics.length ||
+      !BURNED_EVENT_TOPIC_HASHES.has(poolLog.topics[0]!)
     ) {
       return acc
     }
@@ -179,7 +180,7 @@ async function getLbtcTokenData(
 ): Promise<OffchainTokenData[]> {
   const lbtcDepositHashes = new Set(
     allLogsInRequest
-      .filter(({ topics }) => LBTC_EVENTS_HASHES.has(topics[0]))
+      .filter(({ topics }) => LBTC_EVENTS_HASHES.has(topics[0]!))
       .map(({ topics }) => topics[3]),
   )
   return Promise.all(