@across-protocol/sdk 4.3.46 → 4.3.47

package/src/clients/BundleDataClient/utils/DataworkerUtils.ts

@@ -18,7 +18,6 @@ import {
   count2DDictionaryValues,
   count3DDictionaryValues,
   toAddressType,
-  isDefined,
 } from "../../../utils";
 import {
   addLastRunningBalance,
@@ -154,15 +153,21 @@ export function _buildPoolRebalanceRoot(
       ([l2TokenAddress, { realizedLpFees: totalRealizedLpFee, totalRefundAmount }]) => {
         // If the repayment token and repayment chain ID do not map to a PoolRebalanceRoute graph, then
         // there are no relevant L1 running balances.
+        if (
+          !clients.hubPoolClient.l2TokenHasPoolRebalanceRoute(
+            toAddressType(l2TokenAddress, repaymentChainId),
+            repaymentChainId,
+            mainnetBundleEndBlock
+          )
+        ) {
+          chainWithRefundsOnly.add(repaymentChainId);
+          return;
+        }
         const l1Token = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
           toAddressType(l2TokenAddress, repaymentChainId),
           repaymentChainId,
           mainnetBundleEndBlock
         );
-        if (!l1Token) {
-          chainWithRefundsOnly.add(repaymentChainId);
-          return;
-        }
         const l1TokenAddr = l1Token.toNative();
         assert(l1Token.isEVM(), `Expected an EVM address: ${l1TokenAddr}`);
 
@@ -188,9 +193,6 @@ export function _buildPoolRebalanceRoot(
           destinationChainId,
           mainnetBundleEndBlock
         );
-
-        assert(isDefined(l1TokenCounterpart), "getRefundInformationFromFill: l1TokenCounterpart is undefined");
-
         const lpFee = deposit.lpFeePct.mul(deposit.inputAmount).div(fixedPointAdjustment);
         updateRunningBalance(
           runningBalances,
@@ -220,8 +222,6 @@ export function _buildPoolRebalanceRoot(
           destinationChainId,
           mainnetBundleEndBlock
         );
-        assert(isDefined(l1TokenCounterpart), "getRefundInformationFromFill: l1TokenCounterpart is undefined");
-
         const lpFee = deposit.lpFeePct.mul(deposit.inputAmount).div(fixedPointAdjustment);
         updateRunningBalance(
           runningBalances,
@@ -277,15 +277,21 @@ export function _buildPoolRebalanceRoot(
       deposits.forEach((deposit) => {
         // If the repayment token and repayment chain ID do not map to a PoolRebalanceRoute graph, then
         // there are no relevant L1 running balances.
+        if (
+          !clients.hubPoolClient.l2TokenHasPoolRebalanceRoute(
+            deposit.inputToken,
+            deposit.originChainId,
+            mainnetBundleEndBlock
+          )
+        ) {
+          chainWithRefundsOnly.add(deposit.originChainId);
+          return;
+        }
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
           toAddressType(inputToken, originChainId),
           originChainId,
           mainnetBundleEndBlock
         );
-        if (!l1TokenCounterpart) {
-          chainWithRefundsOnly.add(deposit.originChainId);
-          return;
-        }
         updateRunningBalance(runningBalances, originChainId, l1TokenCounterpart.toEvmAddress(), deposit.inputAmount);
       });
     });

package/src/clients/BundleDataClient/utils/FillUtils.ts

@@ -37,21 +37,18 @@ export function getRefundInformationFromFill(
 
   // Now figure out the equivalent L2 token for the repayment token. If the inputToken doesn't have a
   // PoolRebalanceRoute, then the repayment chain would have been the originChainId after the getRepaymentChainId()
-  // call and we would have returned already, so the following call should always return a valid L1 token.
+  // call and we would have returned already, so the following call should always succeed.
   const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
     relayData.inputToken,
     relayData.originChainId,
     bundleEndBlockForMainnet
   );
 
-  assert(isDefined(l1TokenCounterpart), "getRefundInformationFromFill: l1TokenCounterpart is undefined");
-
   const repaymentToken = hubPoolClient.getL2TokenForL1TokenAtBlock(
     l1TokenCounterpart,
     chainToSendRefundTo,
     bundleEndBlockForMainnet
   );
-  assert(isDefined(repaymentToken), "getRefundInformationFromFill: repaymentToken is undefined");
 
   return {
     chainToSendRefundTo,
@@ -186,9 +183,6 @@ function _repaymentChainTokenIsValid(
     relayData.originChainId,
     bundleEndBlockForMainnet
   );
-  if (!l1TokenCounterpart) {
-    return false;
-  }
   if (
     !hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
       l1TokenCounterpart,

package/src/clients/BundleDataClient/utils/PoolRebalanceUtils.ts

@@ -202,8 +202,6 @@ export function updateRunningBalanceForDeposit(
     deposit.originChainId,
     mainnetBundleEndBlock
   );
-  assert(isDefined(l1TokenCounterpart), "updateRunningBalanceForDeposit: l1TokenCounterpart is undefined");
-
   updateRunningBalance(runningBalances, deposit.originChainId, l1TokenCounterpart.toEvmAddress(), updateAmount);
 }
 

package/src/clients/HubPoolClient.ts

@@ -34,6 +34,7 @@ import {
   fetchTokenInfo,
   getCachedBlockForTimestamp,
   getCurrentTime,
+  getNetworkName,
   isDefined,
   mapAsync,
   paginatedEventQuery,
@@ -74,11 +75,17 @@ type HubPoolEvent =
   | "RootBundleExecuted"
   | "CrossChainContractsSet";
 
+type L1TokensToDestinationTokens = {
+  [l1Token: string]: { [destinationChainId: number]: Address };
+};
+
 export type LpFeeRequest = Pick<Deposit, "originChainId" | "inputToken" | "inputAmount" | "quoteTimestamp"> & {
   paymentChainId?: number;
 };
 
 export class HubPoolClient extends BaseAbstractClient {
+  // L1Token -> destinationChainId -> destinationToken
+  protected l1TokensToDestinationTokens: L1TokensToDestinationTokens = {};
   protected l1Tokens: L1TokenInfo[] = []; // L1Tokens and their associated info.
   // @dev `token` here is a 20-byte hex sting
   protected lpTokens: { [token: string]: LpToken } = {};
@@ -185,16 +192,24 @@ export class HubPoolClient extends BaseAbstractClient {
     l1Token: EvmAddress,
     destinationChainId: number,
     latestHubBlock = Number.MAX_SAFE_INTEGER
-  ): Address | undefined {
+  ): Address {
     if (!this.l1TokensToDestinationTokensWithBlock?.[l1Token.toEvmAddress()]?.[destinationChainId]) {
-      return undefined;
+      const chain = getNetworkName(destinationChainId);
+      const { symbol } = this.l1Tokens.find(({ address }) => address.eq(l1Token)) ?? { symbol: l1Token.toString() };
+      throw new Error(`Could not find SpokePool mapping for ${symbol} on ${chain} and L1 token ${l1Token}`);
     }
     // Find the last mapping published before the target block.
-    const l2Token: DestinationTokenWithBlock | undefined = this.l1TokensToDestinationTokensWithBlock[
-      l1Token.toEvmAddress()
-    ][destinationChainId].find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= latestHubBlock);
-
-    return !l2Token || l2Token.l2Token.isZeroAddress() ? undefined : l2Token.l2Token;
+    const l2Token: DestinationTokenWithBlock | undefined = sortEventsDescending(
+      this.l1TokensToDestinationTokensWithBlock[l1Token.toEvmAddress()][destinationChainId]
+    ).find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= latestHubBlock);
+    if (!l2Token) {
+      const chain = getNetworkName(destinationChainId);
+      const { symbol } = this.l1Tokens.find(({ address }) => address.eq(l1Token)) ?? { symbol: l1Token.toString() };
+      throw new Error(
+        `Could not find SpokePool mapping for ${symbol} on ${chain} at or before HubPool block ${latestHubBlock}!`
+      );
+    }
+    return l2Token.l2Token;
   }
 
   // Returns the latest L1 token to use for an L2 token as of the input hub block.
@@ -202,27 +217,32 @@ export class HubPoolClient extends BaseAbstractClient {
     l2Token: Address,
     destinationChainId: number,
     latestHubBlock = Number.MAX_SAFE_INTEGER
-  ): EvmAddress | undefined {
-    const l2Tokens = Object.keys(this.l1TokensToDestinationTokensWithBlock).flatMap((l1Token) => {
-      // Get the latest L2 token mapping for the given L1 token.
-      // @dev Since tokens on L2s (like Solana) can have 32 byte addresses, filter on the lower 20 bytes of the token only.
-      const sortedL2Tokens = sortEventsDescending(
-        (this.l1TokensToDestinationTokensWithBlock[l1Token][destinationChainId] ?? []).filter(
-          (dstTokenWithBlock) => dstTokenWithBlock.blockNumber <= latestHubBlock
-        )
+  ): EvmAddress {
+    const l2Tokens = Object.keys(this.l1TokensToDestinationTokensWithBlock)
+      .filter((l1Token) => this.l2TokenEnabledForL1Token(EvmAddress.from(l1Token), destinationChainId))
+      .map((l1Token) => {
+        // Return all matching L2 token mappings that are equal to or earlier than the target block.
+        // @dev Since tokens on L2s (like Solana) can have 32 byte addresses, filter on the lower 20 bytes of the token only.
+        return this.l1TokensToDestinationTokensWithBlock[l1Token][destinationChainId].filter(
+          (dstTokenWithBlock) =>
+            dstTokenWithBlock.l2Token.truncateToBytes20() === l2Token.truncateToBytes20() &&
+            dstTokenWithBlock.blockNumber <= latestHubBlock
+        );
+      })
+      .flat();
+    if (l2Tokens.length === 0) {
+      const chain = getNetworkName(destinationChainId);
+      throw new Error(
+        `Could not find HubPool mapping for ${l2Token} on ${chain} at or before HubPool block ${latestHubBlock}!`
       );
-      // If the latest L2 token mapping is equal to the target L2 token, return it.
-      return sortedL2Tokens.length > 0 && sortedL2Tokens[0].l2Token.truncateToBytes20() === l2Token.truncateToBytes20()
-        ? sortedL2Tokens[0]
-        : [];
-    });
-
-    return l2Tokens.length === 0 ? undefined : sortEventsDescending(l2Tokens)[0].l1Token;
+    }
+    // Find the last mapping published before the target block.
+    return sortEventsDescending(l2Tokens)[0].l1Token;
   }
 
   protected getL1TokenForDeposit(
     deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">
-  ): EvmAddress | undefined {
+  ): EvmAddress {
     // L1-->L2 token mappings are set via PoolRebalanceRoutes which occur on mainnet,
     // so we use the latest token mapping. This way if a very old deposit is filled, the relayer can use the
     // latest L2 token mapping to find the L1 token counterpart.
@@ -230,7 +250,7 @@ export class HubPoolClient extends BaseAbstractClient {
   }
 
   l2TokenEnabledForL1Token(l1Token: EvmAddress, destinationChainId: number): boolean {
-    return this.l2TokenEnabledForL1TokenAtBlock(l1Token, destinationChainId, Number.MAX_SAFE_INTEGER);
+    return this.l1TokensToDestinationTokens?.[l1Token.toEvmAddress()]?.[destinationChainId] != undefined;
   }
 
   l2TokenEnabledForL1TokenAtBlock(l1Token: EvmAddress, destinationChainId: number, hubBlockNumber: number): boolean {
@@ -238,12 +258,21 @@ export class HubPoolClient extends BaseAbstractClient {
     const l2Token: DestinationTokenWithBlock | undefined = sortEventsDescending(
       this.l1TokensToDestinationTokensWithBlock?.[l1Token.toEvmAddress()]?.[destinationChainId] ?? []
     ).find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= hubBlockNumber);
-    return l2Token !== undefined && !l2Token.l2Token.isZeroAddress();
+    return l2Token !== undefined;
   }
 
   l2TokenHasPoolRebalanceRoute(l2Token: Address, l2ChainId: number, hubPoolBlock = this.latestHeightSearched): boolean {
-    const l1Token = this.getL1TokenForL2TokenAtBlock(l2Token, l2ChainId, hubPoolBlock);
-    return l1Token !== undefined;
+    return Object.values(this.l1TokensToDestinationTokensWithBlock).some((destinationTokenMapping) => {
+      return Object.entries(destinationTokenMapping).some(([_l2ChainId, setPoolRebalanceRouteEvents]) => {
+        return setPoolRebalanceRouteEvents.some((e) => {
+          return (
+            e.blockNumber <= hubPoolBlock &&
+            e.l2Token.truncateToBytes20() === l2Token.truncateToBytes20() &&
+            Number(_l2ChainId) === l2ChainId
+          );
+        });
+      });
+    });
   }
 
   /**
@@ -378,11 +407,9 @@ export class HubPoolClient extends BaseAbstractClient {
     const hubPoolTokens: { [k: string]: EvmAddress } = {};
     const getHubPoolToken = (deposit: LpFeeRequest, quoteBlockNumber: number): EvmAddress | undefined => {
       const tokenKey = `${deposit.originChainId}-${deposit.inputToken}`;
-      const l1Token = this.getL1TokenForDeposit({ ...deposit, quoteBlockNumber });
-      if (!l1Token) {
-        return undefined;
-      }
-      return (hubPoolTokens[tokenKey] ??= l1Token);
+      if (this.l2TokenHasPoolRebalanceRoute(deposit.inputToken, deposit.originChainId, quoteBlockNumber)) {
+        return (hubPoolTokens[tokenKey] ??= this.getL1TokenForDeposit({ ...deposit, quoteBlockNumber }));
+      } else return undefined;
     };
     const getHubPoolTokens = (): EvmAddress[] => dedupArray(Object.values(hubPoolTokens).filter(isDefined));
 
@@ -521,14 +548,14 @@ export class HubPoolClient extends BaseAbstractClient {
     // Resolve both SpokePool tokens back to their respective HubPool tokens and verify that they match.
     const l1TokenA = this.getL1TokenForL2TokenAtBlock(tokenA, chainIdA, hubPoolBlock);
     const l1TokenB = this.getL1TokenForL2TokenAtBlock(tokenB, chainIdB, hubPoolBlock);
-    if (!l1TokenA || !l1TokenB || !l1TokenA.eq(l1TokenB)) {
+    if (!l1TokenA.eq(l1TokenB)) {
       return false;
     }
 
     // Resolve both HubPool tokens back to a current SpokePool token and verify that they match.
     const _tokenA = this.getL2TokenForL1TokenAtBlock(l1TokenA, chainIdA, hubPoolBlock);
     const _tokenB = this.getL2TokenForL1TokenAtBlock(l1TokenB, chainIdB, hubPoolBlock);
-    return _tokenA !== undefined && _tokenB !== undefined && tokenA.eq(_tokenA) && tokenB.eq(_tokenB);
+    return tokenA.eq(_tokenA) && tokenB.eq(_tokenB);
   }
 
   getSpokeActivationBlockForChain(chainId: number): number {
@@ -968,22 +995,24 @@ export class HubPoolClient extends BaseAbstractClient {
           destinationToken = svmUsdc;
         }
 
-        const newRoute: DestinationTokenWithBlock = {
-          l1Token: EvmAddress.from(args.l1Token),
-          l2Token: destinationToken,
-          blockNumber: args.blockNumber,
-          txnIndex: args.txnIndex,
-          logIndex: args.logIndex,
-          txnRef: args.txnRef,
-        };
-        if (this.l1TokensToDestinationTokensWithBlock[args.l1Token]?.[args.destinationChainId]) {
-          // Events are most likely coming in descending orders already but just in case we sort them again.
-          this.l1TokensToDestinationTokensWithBlock[args.l1Token][args.destinationChainId] = sortEventsDescending([
-            ...this.l1TokensToDestinationTokensWithBlock[args.l1Token][args.destinationChainId],
-            newRoute,
-          ]);
-        } else {
-          assign(this.l1TokensToDestinationTokensWithBlock, [args.l1Token, args.destinationChainId], [newRoute]);
+        // If the destination token is set to the zero address in an event, then this means Across should no longer
+        // rebalance to this chain.
+        if (!destinationToken.isZeroAddress()) {
+          assign(this.l1TokensToDestinationTokens, [args.l1Token, args.destinationChainId], destinationToken);
+          assign(
+            this.l1TokensToDestinationTokensWithBlock,
+            [args.l1Token, args.destinationChainId],
+            [
+              {
+                l1Token: EvmAddress.from(args.l1Token),
+                l2Token: destinationToken,
+                blockNumber: args.blockNumber,
+                txnIndex: args.txnIndex,
+                logIndex: args.logIndex,
+                txnRef: args.txnRef,
+              },
+            ]
+          );
         }
       }
     }

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -11,6 +11,7 @@ import { DepositWithBlock, FillStatus, RelayData } from "../../interfaces";
 import {
   BigNumber,
   DepositSearchResult,
+  getMessageHash,
   getNetworkName,
   InvalidFill,
   MakeOptional,
@@ -194,18 +195,31 @@ export class EVMSpokePoolClient extends SpokePoolClient {
       };
     }
 
+    const spreadEvent = spreadEventWithBlockNumber(event) as Omit<
+      DepositWithBlock,
+      "originChainId" | "inputToken" | "outputToken" | "depositor" | "recipient" | "exclusiveRelayer"
+    > & {
+      inputToken: string;
+      outputToken: string;
+      depositor: string;
+      recipient: string;
+      exclusiveRelayer: string;
+    };
+
+    const originChainId = this.chainId;
     deposit = {
-      ...spreadEventWithBlockNumber(event),
-      inputToken: toAddressType(event.args.inputToken, event.args.originChainId),
-      outputToken: toAddressType(event.args.outputToken, event.args.destinationChainId),
-      depositor: toAddressType(event.args.depositor, this.chainId),
-      recipient: toAddressType(event.args.recipient, event.args.destinationChainId),
-      exclusiveRelayer: toAddressType(event.args.exclusiveRelayer, event.args.destinationChainId),
+      ...spreadEvent,
       originChainId: this.chainId,
-      quoteBlockNumber: await this.getBlockNumber(Number(event.args["quoteTimestamp"])),
+      inputToken: toAddressType(spreadEvent.inputToken, originChainId),
+      outputToken: toAddressType(spreadEvent.outputToken, spreadEvent.destinationChainId),
+      depositor: toAddressType(spreadEvent.depositor, originChainId),
+      recipient: toAddressType(spreadEvent.recipient, spreadEvent.destinationChainId),
+      exclusiveRelayer: toAddressType(spreadEvent.exclusiveRelayer, spreadEvent.destinationChainId),
+      quoteBlockNumber: await this.getBlockNumber(spreadEvent.quoteTimestamp),
+      messageHash: getMessageHash(spreadEvent.message),
       fromLiteChain: true, // To be updated immediately afterwards.
       toLiteChain: true, // To be updated immediately afterwards.
-    } as DepositWithBlock;
+    };
 
     if (deposit.outputToken.isZeroAddress()) {
       deposit.outputToken = this.getDestinationTokenForDeposit(deposit);

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -472,22 +472,18 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
       )
     ) {
       return false;
+    } else {
+      const l1Token = this.hubPoolClient?.getL1TokenForL2TokenAtBlock(
+        deposit.inputToken,
+        deposit.originChainId,
+        deposit.quoteBlockNumber
+      );
+      return this.hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
+        l1Token,
+        deposit.destinationChainId,
+        deposit.quoteBlockNumber
+      );
     }
-
-    const l1Token = this.hubPoolClient?.getL1TokenForL2TokenAtBlock(
-      deposit.inputToken,
-      deposit.originChainId,
-      deposit.quoteBlockNumber
-    );
-    if (!l1Token) {
-      return false;
-    }
-
-    return this.hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
-      l1Token,
-      deposit.destinationChainId,
-      deposit.quoteBlockNumber
-    );
   }
 
   /**
@@ -523,11 +519,12 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     }
 
     // Performs the indexing of a deposit-like spoke pool event.
+    const originChainId = this.chainId;
     const queryDepositEvents = async (eventName: string) => {
       const depositEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((_event) => {
         const event = _event as Omit<
           DepositWithBlock,
-          "depositor" | "recipient" | "inputToken" | "outputToken" | "exclusiveRelayer"
+          "originChainId" | "depositor" | "recipient" | "inputToken" | "outputToken" | "exclusiveRelayer"
         > & {
           depositor: string;
           recipient: string;
@@ -537,12 +534,14 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         };
         return {
           ...event,
-          depositor: toAddressType(event.depositor, this.chainId),
+          originChainId,
+          depositor: toAddressType(event.depositor, originChainId),
           recipient: toAddressType(event.recipient, event.destinationChainId),
-          inputToken: toAddressType(event.inputToken, this.chainId),
+          inputToken: toAddressType(event.inputToken, originChainId),
           outputToken: toAddressType(event.outputToken, event.destinationChainId),
           exclusiveRelayer: toAddressType(event.exclusiveRelayer, event.destinationChainId),
-        } as DepositWithBlock;
+          messageHash: getMessageHash(event.message),
+        } satisfies Omit<DepositWithBlock, "quoteBlockNumber" | "fromLiteChain" | "toLiteChain">;
       });
       if (depositEvents.length > 0) {
         this.log(
@@ -563,17 +562,11 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         // Derive and append the common properties that are not part of the onchain event.
         const deposit = {
           ...event,
-          messageHash: getMessageHash(event.message),
           quoteBlockNumber,
-          originChainId: this.chainId,
-          // The following properties are placeholders to be updated immediately.
-          fromLiteChain: true,
-          toLiteChain: true,
+          fromLiteChain: this.isOriginLiteChain(event),
+          toLiteChain: this.isDestinationLiteChain(event),
         };
 
-        deposit.fromLiteChain = this.isOriginLiteChain(deposit);
-        deposit.toLiteChain = this.isDestinationLiteChain(deposit);
-
         if (deposit.outputToken.isZeroAddress()) {
           deposit.outputToken = this.getDestinationTokenForDeposit(deposit);
         }
@@ -697,10 +690,12 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     });
 
     // Performs indexing of filled relay-like events.
+    const destinationChainId = this.chainId;
     const queryFilledRelayEvents = (eventName: string) => {
       const fillEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((_event) => {
         const event = _event as Omit<
           FillWithBlock,
+          | "destinationChainId"
           | "depositor"
           | "recipient"
           | "inputToken"
@@ -717,19 +712,21 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
           relayer: string;
           relayExecutionInfo: Omit<RelayExecutionEventInfo, "updatedRecipient"> & { updatedRecipient: string };
         };
+
         return {
           ...event,
+          destinationChainId,
           depositor: toAddressType(event.depositor, event.originChainId),
-          recipient: toAddressType(event.recipient, this.chainId),
+          recipient: toAddressType(event.recipient, destinationChainId),
           inputToken: toAddressType(event.inputToken, event.originChainId),
-          outputToken: toAddressType(event.outputToken, this.chainId),
-          exclusiveRelayer: toAddressType(event.exclusiveRelayer, this.chainId),
-          relayer: toAddressType(event.relayer, this.chainId),
+          outputToken: toAddressType(event.outputToken, destinationChainId),
+          exclusiveRelayer: toAddressType(event.exclusiveRelayer, destinationChainId),
+          relayer: toAddressType(event.relayer, event.repaymentChainId),
           relayExecutionInfo: {
             ...event.relayExecutionInfo,
             updatedRecipient: toAddressType(event.relayExecutionInfo.updatedRecipient, this.chainId),
           },
-        } as FillWithBlock;
+        } satisfies FillWithBlock;
       });
 
       if (fillEvents.length > 0) {
@@ -740,16 +737,11 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
       // @note The type assertions here suppress errors that might arise due to incomplete types. For now, verify via
       // test that the types are complete. A broader change in strategy for safely unpacking events will be introduced.
-      for (const event of fillEvents) {
-        const fill = {
-          ...event,
-          destinationChainId: this.chainId,
-        };
-
+      for (const fill of fillEvents) {
         // Sanity check that this event is not a duplicate.
         const duplicateFill = this.fills[fill.originChainId]?.find((f) => duplicateEvent(fill, f));
         if (duplicateFill) {
-          duplicateEvents.push(event);
+          duplicateEvents.push(fill);
           continue;
         }
 

package/src/clients/mocks/MockHubPoolClient.ts

@@ -118,9 +118,9 @@ export class MockHubPoolClient extends HubPoolClient {
     delete this.spokePoolTokens[l1Token]?.[chainId];
   }
 
-  getL1TokenForL2TokenAtBlock(l2Token: Address, chainId: number, blockNumber: number): EvmAddress | undefined {
+  getL1TokenForL2TokenAtBlock(l2Token: Address, chainId: number, blockNumber: number): EvmAddress {
     const l1Token = Object.keys(this.spokePoolTokens).find(
-      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId]?.eq(l2Token)
+      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId].eq(l2Token)
     );
     if (isDefined(l1Token)) {
       return EvmAddress.from(l1Token);
@@ -129,7 +129,7 @@ export class MockHubPoolClient extends HubPoolClient {
     }
   }
 
-  getL2TokenForL1TokenAtBlock(l1Token: EvmAddress, chainId: number, blockNumber: number): Address | undefined {
+  getL2TokenForL1TokenAtBlock(l1Token: EvmAddress, chainId: number, blockNumber: number): Address {
     const l2Token = this.spokePoolTokens[l1Token.toEvmAddress()]?.[chainId];
     return l2Token ?? super.getL2TokenForL1TokenAtBlock(l1Token, chainId, blockNumber);
   }

package/src/constants.ts

@@ -93,3 +93,15 @@ export const CUSTOM_GAS_TOKENS = {
   [CHAIN_IDs.LENS]: "GHO",
   [CHAIN_IDs.LENS_SEPOLIA]: "GHO",
 };
+
+// Blocks where SpokePools were upgraded from v2 to v2.5. This is where the fillStatus mapping
+// was introduced. This mapping should only be updated on subsequent upgrades where there are
+// breaking changes and the exact upgrade block is required to bound certain queries.
+export const SPOKEPOOL_UPGRADE_BLOCKS = {
+  [CHAIN_IDs.ARBITRUM]: 183082059,
+  [CHAIN_IDs.BASE]: 10874747,
+  [CHAIN_IDs.MAINNET]: 19277695,
+  [CHAIN_IDs.OPTIMISM]: 116469982,
+  [CHAIN_IDs.POLYGON]: 53793776,
+  [CHAIN_IDs.ZK_SYNC]: 27157340,
+};