@across-protocol/sdk 4.3.57 → 4.3.59-alpha.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.3.57",
+  "version": "4.3.59-alpha.1",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [
@@ -34,7 +34,7 @@
     "bump-version:minor": "yarn version --minor --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
     "bump-version:patch": "yarn version --patch --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
     "typechain": "typechain --target ethers-v5 --out-dir src/utils/abi/typechain 'src/utils/abi/contracts/*.json' && eslint --fix src/utils/abi/typechain && yarn prettier --write \"src/utils/abi/typechain/**/*.ts\"",
-    "yalc:watch": "nodemon --watch src --ext ts,tsx,json,js,jsx --exec 'yalc push'"
+    "yalc:watch": "nodemon --watch src --ext ts,tsx,json,js,jsx --ignore src/utils/abi/ --exec 'yalc publish --push --changed'"
   },
   "lint-staged": {
     "*.ts": "yarn lint"

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -54,7 +54,7 @@ import {
   getRefundInformationFromFill,
   getRefundsFromBundle,
   getWidestPossibleExpectedBlockRange,
-  isChainDisabled,
+  isChainDisabledAtBlock,
   prettyPrintV3SpokePoolEvents,
   V3DepositWithBlock,
   V3FillWithBlock,
@@ -761,8 +761,8 @@ export class BundleDataClient {
       throw new Error("HubPoolClient not updated");
     }
 
-    const chainIds = this.clients.configStoreClient.getChainIdIndicesForBlock(blockRangesForChains[0][0]);
-    const bundleEndBlockForMainnet = blockRangesForChains[0][1];
+    const [bundleStartBlockForMainnet, bundleEndBlockForMainnet] = blockRangesForChains[0];
+    const chainIds = this.clients.configStoreClient.getChainIdIndicesForBlock(bundleStartBlockForMainnet);
 
     if (blockRangesForChains.length > chainIds.length) {
       throw new Error(
@@ -786,11 +786,6 @@ export class BundleDataClient {
     // (2) the fill deadline has passed. We'll need to decrement running balances for these deposits on the
     // destination chain where the slow fill would have been executed.
 
-    const _isChainDisabled = (chainId: number): boolean => {
-      const blockRangeForChain = getBlockRangeForChain(blockRangesForChains, chainId, chainIds);
-      return isChainDisabled(blockRangeForChain);
-    };
-
     const _canCreateSlowFillLeaf = (deposit: DepositWithBlock): boolean => {
       return (
         // Cannot slow fill when input and output tokens are not equivalent.
@@ -826,7 +821,11 @@ export class BundleDataClient {
     // Infer chain ID's to load from number of block ranges passed in.
     const allChainIds = blockRangesForChains
       .map((_blockRange, index) => chainIds[index])
-      .filter((chainId) => !_isChainDisabled(chainId) && spokePoolClients[chainId] !== undefined);
+      .filter(
+        (chainId) =>
+          !isChainDisabledAtBlock(chainId, bundleStartBlockForMainnet, this.clients.configStoreClient) &&
+          spokePoolClients[chainId] !== undefined
+      );
     allChainIds.forEach((chainId) => {
       const spokePoolClient = spokePoolClients[chainId];
       if (!spokePoolClient.isUpdated) {
@@ -1676,7 +1675,10 @@ export class BundleDataClient {
       (
         await mapAsync(chainIds, async (chainId, index) => {
           const blockRangeForChain = blockRangesForChains[index];
-          if (!isDefined(blockRangeForChain) || isChainDisabled(blockRangeForChain)) {
+          if (
+            !isDefined(blockRangeForChain) ||
+            isChainDisabledAtBlock(chainId, blockRangesForChains[0][0], this.clients.configStoreClient)
+          ) {
             return;
           }
           const [_startBlockForChain, _endBlockForChain] = blockRangeForChain;

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

@@ -399,21 +399,15 @@ export function _getMarginalRunningBalances(
       ([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}`);
 
@@ -439,6 +433,9 @@ export function _getMarginalRunningBalances(
           destinationChainId,
           mainnetBundleEndBlock
         );
+
+        assert(isDefined(l1TokenCounterpart), "getRefundInformationFromFill: l1TokenCounterpart is undefined");
+
         const lpFee = deposit.lpFeePct.mul(deposit.inputAmount).div(fixedPointAdjustment);
         updateRunningBalance(
           runningBalances,
@@ -468,6 +465,8 @@ export function _getMarginalRunningBalances(
           destinationChainId,
           mainnetBundleEndBlock
         );
+        assert(isDefined(l1TokenCounterpart), "getRefundInformationFromFill: l1TokenCounterpart is undefined");
+
         const lpFee = deposit.lpFeePct.mul(deposit.inputAmount).div(fixedPointAdjustment);
         updateRunningBalance(
           runningBalances,
@@ -523,21 +522,15 @@ export function _getMarginalRunningBalances(
       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,18 +37,21 @@ 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 succeed.
+  // call and we would have returned already, so the following call should always return a valid L1 token.
   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,
@@ -183,6 +186,9 @@ function _repaymentChainTokenIsValid(
     relayData.originChainId,
     bundleEndBlockForMainnet
   );
+  if (!l1TokenCounterpart) {
+    return false;
+  }
   if (
     !hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
       l1TokenCounterpart,

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

@@ -98,8 +98,12 @@ export async function getWidestPossibleExpectedBlockRange(
   });
 }
 
-export function isChainDisabled(blockRangeForChain: number[]): boolean {
-  return blockRangeForChain[0] === blockRangeForChain[1];
+export function isChainDisabledAtBlock(
+  chainId: number,
+  mainnetBlock: number,
+  configStoreClient: AcrossConfigStoreClient
+): boolean {
+  return configStoreClient.getDisabledChainsForBlock(mainnetBlock).includes(chainId);
 }
 
 // Note: this function computes the intended transfer amount before considering the transfer threshold.
@@ -202,6 +206,8 @@ 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,7 +34,6 @@ import {
   fetchTokenInfo,
   getCachedBlockForTimestamp,
   getCurrentTime,
-  getNetworkName,
   isDefined,
   mapAsync,
   paginatedEventQuery,
@@ -75,17 +74,11 @@ 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 } = {};
@@ -192,24 +185,16 @@ export class HubPoolClient extends BaseAbstractClient {
     l1Token: EvmAddress,
     destinationChainId: number,
     latestHubBlock = Number.MAX_SAFE_INTEGER
-  ): Address {
+  ): Address | undefined {
     if (!this.l1TokensToDestinationTokensWithBlock?.[l1Token.toNative()]?.[destinationChainId]) {
-      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}`);
+      return undefined;
     }
     // Find the last mapping published before the target block.
-    const l2Token: DestinationTokenWithBlock | undefined = sortEventsDescending(
-      this.l1TokensToDestinationTokensWithBlock[l1Token.toNative()][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;
+    const l2Token: DestinationTokenWithBlock | undefined = this.l1TokensToDestinationTokensWithBlock[
+      l1Token.toNative()
+    ][destinationChainId].find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= latestHubBlock);
+
+    return !isDefined(l2Token) || l2Token.l2Token.isZeroAddress() ? undefined : l2Token.l2Token;
   }
 
   // Returns the latest L1 token to use for an L2 token as of the input hub block.
@@ -217,32 +202,27 @@ export class HubPoolClient extends BaseAbstractClient {
     l2Token: Address,
     destinationChainId: number,
     latestHubBlock = Number.MAX_SAFE_INTEGER
-  ): 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}!`
+  ): 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
+        )
       );
-    }
-    // Find the last mapping published before the target block.
-    return sortEventsDescending(l2Tokens)[0].l1Token;
+      // 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;
   }
 
   protected getL1TokenForDeposit(
     deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">
-  ): EvmAddress {
+  ): EvmAddress | undefined {
     // 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.
@@ -250,7 +230,7 @@ export class HubPoolClient extends BaseAbstractClient {
   }
 
   l2TokenEnabledForL1Token(l1Token: EvmAddress, destinationChainId: number): boolean {
-    return this.l1TokensToDestinationTokens?.[l1Token.toNative()]?.[destinationChainId] != undefined;
+    return this.l2TokenEnabledForL1TokenAtBlock(l1Token, destinationChainId, Number.MAX_SAFE_INTEGER);
   }
 
   l2TokenEnabledForL1TokenAtBlock(l1Token: EvmAddress, destinationChainId: number, hubBlockNumber: number): boolean {
@@ -258,21 +238,12 @@ export class HubPoolClient extends BaseAbstractClient {
     const l2Token: DestinationTokenWithBlock | undefined = sortEventsDescending(
       this.l1TokensToDestinationTokensWithBlock?.[l1Token.toNative()]?.[destinationChainId] ?? []
     ).find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= hubBlockNumber);
-    return l2Token !== undefined;
+    return isDefined(l2Token) && !l2Token.l2Token.isZeroAddress();
   }
 
   l2TokenHasPoolRebalanceRoute(l2Token: Address, l2ChainId: number, hubPoolBlock = this.latestHeightSearched): boolean {
-    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
-          );
-        });
-      });
-    });
+    const l1Token = this.getL1TokenForL2TokenAtBlock(l2Token, l2ChainId, hubPoolBlock);
+    return isDefined(l1Token);
   }
 
   /**
@@ -401,11 +372,11 @@ export class HubPoolClient extends BaseAbstractClient {
     const hubPoolTokens: { [k: string]: EvmAddress } = {};
     const getHubPoolToken = (deposit: LpFeeRequest, quoteBlockNumber: number): EvmAddress | undefined => {
       const tokenKey = `${deposit.originChainId}-${deposit.inputToken}`;
-      if (this.l2TokenHasPoolRebalanceRoute(deposit.inputToken, deposit.originChainId, quoteBlockNumber)) {
-        return (hubPoolTokens[tokenKey] ??= this.getL1TokenForDeposit({ ...deposit, quoteBlockNumber }));
+      const l1Token = this.getL1TokenForDeposit({ ...deposit, quoteBlockNumber });
+      if (!isDefined(l1Token)) {
+        return undefined;
       }
-
-      return undefined;
+      return (hubPoolTokens[tokenKey] ??= l1Token);
     };
 
     // Filter hubPoolTokens for duplicates by reverting to their native string
@@ -553,14 +524,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.eq(l1TokenB)) {
+    if (!isDefined(l1TokenA) || !isDefined(l1TokenB) || !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.eq(_tokenA) && tokenB.eq(_tokenB);
+    return isDefined(_tokenA) && isDefined(_tokenB) && tokenA.eq(_tokenA) && tokenB.eq(_tokenB);
   }
 
   getSpokeActivationBlockForChain(chainId: number): number {
@@ -1001,24 +972,22 @@ export class HubPoolClient extends BaseAbstractClient {
           destinationToken = svmUsdc;
         }
 
-        // 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,
-              },
-            ]
-          );
+        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]);
         }
       }
     }

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -7,7 +7,7 @@ import {
   relayFillStatus,
   getTimestampForBlock as _getTimestampForBlock,
 } from "../../arch/evm";
-import { DepositWithBlock, FillStatus, RelayData } from "../../interfaces";
+import { DepositWithBlock, FillStatus, Log, RelayData } from "../../interfaces";
 import {
   BigNumber,
   DepositSearchResult,
@@ -155,45 +155,14 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     }
 
     // No deposit found; revert to searching for it.
-    const upperBound = this.latestHeightSearched || undefined; // Don't permit block 0 as the high block.
-    const from = await findDepositBlock(this.spokePool, depositId, this.deploymentBlock, upperBound);
-    const chain = getNetworkName(this.chainId);
-    if (!from) {
-      const reason =
-        `Unable to find ${chain} depositId ${depositId}` +
-        ` within blocks [${this.deploymentBlock}, ${upperBound ?? "latest"}].`;
-      return { found: false, code: InvalidFill.DepositIdNotFound, reason };
-    }
+    const result = await this.queryDepositEvents(depositId);
 
-    const to = from;
-    const tStart = Date.now();
-    // Check both V3FundsDeposited and FundsDeposited events to look for a specified depositId.
-    const { maxLookBack } = this.eventSearchConfig;
-    const query = (
-      await Promise.all([
-        paginatedEventQuery(
-          this.spokePool,
-          this.spokePool.filters.V3FundsDeposited(null, null, null, null, null, depositId),
-          { from, to, maxLookBack }
-        ),
-        paginatedEventQuery(
-          this.spokePool,
-          this.spokePool.filters.FundsDeposited(null, null, null, null, null, depositId),
-          { from, to, maxLookBack }
-        ),
-      ])
-    ).flat();
-    const tStop = Date.now();
-
-    const event = query.find(({ args }) => args["depositId"].eq(depositId));
-    if (event === undefined) {
-      return {
-        found: false,
-        code: InvalidFill.DepositIdNotFound,
-        reason: `${chain} depositId ${depositId} not found at block ${from}.`,
-      };
+    if ("reason" in result) {
+      return { found: false, code: InvalidFill.DepositIdNotFound, reason: result.reason };
     }
 
+    const { event, elapsedMs } = result;
+
     const partialDeposit = unpackDepositEvent(spreadEventWithBlockNumber(event), this.chainId);
     const quoteBlockNumber = await this.getBlockNumber(partialDeposit.quoteTimestamp);
     const outputToken = partialDeposit.outputToken.isZeroAddress()
@@ -212,13 +181,59 @@ export class EVMSpokePoolClient extends SpokePoolClient {
       at: "SpokePoolClient#findDeposit",
       message: "Located deposit outside of SpokePoolClient's search range",
       deposit,
-      elapsedMs: tStop - tStart,
+      elapsedMs,
     });
-
     return { found: true, deposit };
   }
 
   public override getTimestampForBlock(blockNumber: number): Promise<number> {
     return _getTimestampForBlock(this.spokePool.provider, blockNumber);
   }
+
+  private async queryDepositEvents(
+    depositId: BigNumber
+  ): Promise<{ event: Log; elapsedMs: number } | { reason: string }> {
+    const tStart = Date.now();
+    const upperBound = this.latestHeightSearched || undefined;
+    const from = await findDepositBlock(this.spokePool, depositId, this.deploymentBlock, upperBound);
+    const chain = getNetworkName(this.chainId);
+
+    if (!from) {
+      return {
+        reason: `Unable to find ${chain} depositId ${depositId} within blocks [${this.deploymentBlock}, ${
+          upperBound ?? "latest"
+        }].`,
+      };
+    }
+
+    const to = from;
+
+    const { maxLookBack } = this.eventSearchConfig;
+    const events = (
+      await Promise.all([
+        paginatedEventQuery(
+          this.spokePool,
+          this.spokePool.filters.V3FundsDeposited(null, null, null, null, null, depositId),
+          { from, to, maxLookBack }
+        ),
+        paginatedEventQuery(
+          this.spokePool,
+          this.spokePool.filters.FundsDeposited(null, null, null, null, null, depositId),
+          { from, to, maxLookBack }
+        ),
+      ])
+    )
+      .flat()
+      .filter(({ args }) => args["depositId"].eq(depositId));
+
+    const tStop = Date.now();
+    const [event] = events;
+    if (!event) {
+      return {
+        reason: `Unable to find ${chain} depositId ${depositId} within blocks [${from}, ${upperBound ?? "latest"}].`,
+      };
+    }
+
+    return { event, elapsedMs: tStop - tStart };
+  }
 }

package/src/clients/SpokePoolClient/SVMSpokePoolClient.ts

@@ -218,6 +218,11 @@ export class SVMSpokePoolClient extends SpokePoolClient {
    * Finds a deposit based on its deposit ID on the SVM chain.
    */
   public async findDeposit(depositId: BigNumber): Promise<DepositSearchResult> {
+    // First check memory for deposits
+    const memoryDeposit = this.getDeposit(depositId);
+    if (memoryDeposit) {
+      return { found: true, deposit: memoryDeposit };
+    }
     const deposit = await findDeposit(this.svmEventsClient, depositId, this.logger);
     if (!deposit) {
       return {

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -474,18 +474,22 @@ 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
+    );
   }
 
   /**

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 {
+  getL1TokenForL2TokenAtBlock(l2Token: Address, chainId: number, blockNumber: number): EvmAddress | undefined {
     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 {
+  getL2TokenForL1TokenAtBlock(l1Token: EvmAddress, chainId: number, blockNumber: number): Address | undefined {
     const l2Token = this.spokePoolTokens[l1Token.toEvmAddress()]?.[chainId];
     return l2Token ?? super.getL2TokenForL1TokenAtBlock(l1Token, chainId, blockNumber);
   }

package/src/interfaces/SpokePool.ts

@@ -175,3 +175,9 @@ export interface SpokePoolClientsByChain {
 export interface RelayDataWithMessageHash extends RelayData {
   messageHash?: string;
 }
+
+export interface InvalidFill {
+  fill: FillWithBlock;
+  reason: string;
+  deposit?: DepositWithBlock;
+}