@across-protocol/sdk 4.0.0-beta.18 → 4.0.0-beta.2

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -33,13 +33,10 @@ import {
   getImpliedBundleBlockRanges,
   isSlowFill,
   mapAsync,
-  filterAsync,
   bnUint32Max,
   isZeroValueDeposit,
   findFillEvent,
   isZeroValueFillOrSlowFillRequest,
-  chainIsEvm,
-  isValidEvmAddress,
 } from "../../utils";
 import winston from "winston";
 import {
@@ -54,9 +51,7 @@ import {
   prettyPrintV3SpokePoolEvents,
   V3DepositWithBlock,
   V3FillWithBlock,
-  verifyFillRepayment,
 } from "./utils";
-import { PRE_FILL_MIN_CONFIG_STORE_VERSION } from "../../constants";
 
 // max(uint256) - 1
 export const INFINITE_FILL_DEADLINE = bnUint32Max;
@@ -65,10 +60,6 @@ type DataCache = Record<string, Promise<LoadDataReturnValue>>;
 
 // V3 dictionary helper functions
 function updateExpiredDepositsV3(dict: ExpiredDepositsToRefundV3, deposit: V3DepositWithBlock): void {
-  // A deposit refund for a deposit is invalid if the depositor has a bytes32 address input for an EVM chain. It is valid otherwise.
-  if (chainIsEvm(deposit.originChainId) && !isValidEvmAddress(deposit.depositor)) {
-    return;
-  }
   const { originChainId, inputToken } = deposit;
   if (!dict?.[originChainId]?.[inputToken]) {
     assign(dict, [originChainId, inputToken], []);
@@ -89,13 +80,8 @@ function updateBundleFillsV3(
   fill: V3FillWithBlock,
   lpFeePct: BigNumber,
   repaymentChainId: number,
-  repaymentToken: string,
-  repaymentAddress: string
+  repaymentToken: string
 ): void {
-  // It is impossible to refund a deposit if the repayment chain is EVM and the relayer is a non-evm address.
-  if (chainIsEvm(repaymentChainId) && !isValidEvmAddress(repaymentAddress)) {
-    return;
-  }
   if (!dict?.[repaymentChainId]?.[repaymentToken]) {
     assign(dict, [repaymentChainId, repaymentToken], {
       fills: [],
@@ -105,19 +91,19 @@ function updateBundleFillsV3(
     });
   }
 
-  const bundleFill: BundleFillV3 = { ...fill, lpFeePct, relayer: repaymentAddress };
+  const bundleFill: BundleFillV3 = { ...fill, lpFeePct };
 
   // Add all fills, slow and fast, to dictionary.
   assign(dict, [repaymentChainId, repaymentToken, "fills"], [bundleFill]);
 
   // All fills update the bundle LP fees.
   const refundObj = dict[repaymentChainId][repaymentToken];
-  const realizedLpFee = bundleFill.inputAmount.mul(bundleFill.lpFeePct).div(fixedPointAdjustment);
+  const realizedLpFee = fill.inputAmount.mul(bundleFill.lpFeePct).div(fixedPointAdjustment);
   refundObj.realizedLpFees = refundObj.realizedLpFees ? refundObj.realizedLpFees.add(realizedLpFee) : realizedLpFee;
 
   // Only fast fills get refunded.
-  if (!isSlowFill(bundleFill)) {
-    const refundAmount = bundleFill.inputAmount.mul(fixedPointAdjustment.sub(lpFeePct)).div(fixedPointAdjustment);
+  if (!isSlowFill(fill)) {
+    const refundAmount = fill.inputAmount.mul(fixedPointAdjustment.sub(lpFeePct)).div(fixedPointAdjustment);
     refundObj.totalRefundAmount = refundObj.totalRefundAmount
       ? refundObj.totalRefundAmount.add(refundAmount)
       : refundAmount;
@@ -125,10 +111,10 @@ function updateBundleFillsV3(
     // Instantiate dictionary if it doesn't exist.
     refundObj.refunds ??= {};
 
-    if (refundObj.refunds[bundleFill.relayer]) {
-      refundObj.refunds[bundleFill.relayer] = refundObj.refunds[bundleFill.relayer].add(refundAmount);
+    if (refundObj.refunds[fill.relayer]) {
+      refundObj.refunds[fill.relayer] = refundObj.refunds[fill.relayer].add(refundAmount);
     } else {
-      refundObj.refunds[bundleFill.relayer] = refundAmount;
+      refundObj.refunds[fill.relayer] = refundAmount;
     }
   }
 }
@@ -296,7 +282,7 @@ export class BundleDataClient {
     // so as not to affect this approximate refund count.
     const arweaveData = await this.loadArweaveData(bundleEvaluationBlockRanges);
     if (arweaveData === undefined) {
-      combinedRefunds = await this.getApproximateRefundsForBlockRange(chainIds, bundleEvaluationBlockRanges);
+      combinedRefunds = this.getApproximateRefundsForBlockRange(chainIds, bundleEvaluationBlockRanges);
     } else {
       const { bundleFillsV3, expiredDepositsToRefundV3 } = arweaveData;
       combinedRefunds = getRefundsFromBundle(bundleFillsV3, expiredDepositsToRefundV3);
@@ -317,72 +303,50 @@ export class BundleDataClient {
   }
 
   // @dev This helper function should probably be moved to the InventoryClient
-  async getApproximateRefundsForBlockRange(chainIds: number[], blockRanges: number[][]): Promise<CombinedRefunds> {
+  getApproximateRefundsForBlockRange(chainIds: number[], blockRanges: number[][]): CombinedRefunds {
     const refundsForChain: CombinedRefunds = {};
     for (const chainId of chainIds) {
       if (this.spokePoolClients[chainId] === undefined) {
         continue;
       }
       const chainIndex = chainIds.indexOf(chainId);
-      // @todo This function does not account for pre-fill refunds as it is optimized for speed. The way to detect
-      // pre-fill refunds is to load all deposits that are unmatched by fills in the spoke pool client's memory
-      // and then query the FillStatus on-chain, but that might slow this function down too much. For now, we
-      // will live with this expected inaccuracy as it should be small. The pre-fill would have to precede the deposit
-      // by more than the caller's event lookback window which is expected to be unlikely.
-      const fillsToCount = await filterAsync(this.spokePoolClients[chainId].getFills(), async (fill) => {
-        if (
-          fill.blockNumber < blockRanges[chainIndex][0] ||
-          fill.blockNumber > blockRanges[chainIndex][1] ||
-          isZeroValueFillOrSlowFillRequest(fill)
-        ) {
-          return false;
-        }
+      this.spokePoolClients[chainId]
+        .getFills()
+        .filter((fill) => {
+          if (fill.blockNumber < blockRanges[chainIndex][0] || fill.blockNumber > blockRanges[chainIndex][1]) {
+            return false;
+          }
 
-        // If origin spoke pool client isn't defined, we can't validate it.
-        if (this.spokePoolClients[fill.originChainId] === undefined) {
-          return false;
-        }
-        const matchingDeposit = this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
-        const hasMatchingDeposit =
-          matchingDeposit !== undefined &&
-          this.getRelayHashFromEvent(fill) === this.getRelayHashFromEvent(matchingDeposit);
-        if (hasMatchingDeposit) {
-          const validRepayment = await verifyFillRepayment(
-            fill,
-            this.spokePoolClients[fill.destinationChainId].spokePool.provider,
-            matchingDeposit,
-            // @dev: to get valid repayment chain ID's, get all chain IDs for the bundle block range and remove
-            // disabled block ranges.
-            this.clients.configStoreClient
-              .getChainIdIndicesForBlock(blockRanges[0][1])
-              .filter((_chainId, i) => !isChainDisabled(blockRanges[i]))
-          );
-          if (!isDefined(validRepayment)) {
+          // If origin spoke pool client isn't defined, we can't validate it.
+          if (this.spokePoolClients[fill.originChainId] === undefined) {
             return false;
           }
-        }
-        return hasMatchingDeposit;
-      });
-      fillsToCount.forEach((fill) => {
-        const matchingDeposit = this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
-        assert(isDefined(matchingDeposit), "Deposit not found for fill.");
-        const { chainToSendRefundTo, repaymentToken } = getRefundInformationFromFill(
-          fill,
-          this.clients.hubPoolClient,
-          blockRanges,
-          this.chainIdListForBundleEvaluationBlockNumbers,
-          matchingDeposit!.fromLiteChain // Use ! because we've already asserted that matchingDeposit is defined.
-        );
-        // Assume that lp fees are 0 for the sake of speed. In the future we could batch compute
-        // these or make hardcoded assumptions based on the origin-repayment chain direction. This might result
-        // in slight over estimations of refunds, but its not clear whether underestimating or overestimating is
-        // worst from the relayer's perspective.
-        const { relayer, inputAmount: refundAmount } = fill;
-        refundsForChain[chainToSendRefundTo] ??= {};
-        refundsForChain[chainToSendRefundTo][repaymentToken] ??= {};
-        const existingRefundAmount = refundsForChain[chainToSendRefundTo][repaymentToken][relayer] ?? bnZero;
-        refundsForChain[chainToSendRefundTo][repaymentToken][relayer] = existingRefundAmount.add(refundAmount);
-      });
+          const matchingDeposit = this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
+          const hasMatchingDeposit =
+            matchingDeposit !== undefined &&
+            this.getRelayHashFromEvent(fill) === this.getRelayHashFromEvent(matchingDeposit);
+          return hasMatchingDeposit;
+        })
+        .forEach((fill) => {
+          const matchingDeposit = this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
+          assert(isDefined(matchingDeposit), "Deposit not found for fill.");
+          const { chainToSendRefundTo, repaymentToken } = getRefundInformationFromFill(
+            fill,
+            this.clients.hubPoolClient,
+            blockRanges,
+            this.chainIdListForBundleEvaluationBlockNumbers,
+            matchingDeposit!.fromLiteChain // Use ! because we've already asserted that matchingDeposit is defined.
+          );
+          // Assume that lp fees are 0 for the sake of speed. In the future we could batch compute
+          // these or make hardcoded assumptions based on the origin-repayment chain direction. This might result
+          // in slight over estimations of refunds, but its not clear whether underestimating or overestimating is
+          // worst from the relayer's perspective.
+          const { relayer, inputAmount: refundAmount } = fill;
+          refundsForChain[chainToSendRefundTo] ??= {};
+          refundsForChain[chainToSendRefundTo][repaymentToken] ??= {};
+          const existingRefundAmount = refundsForChain[chainToSendRefundTo][repaymentToken][relayer] ?? bnZero;
+          refundsForChain[chainToSendRefundTo][repaymentToken][relayer] = existingRefundAmount.add(refundAmount);
+        });
     }
     return refundsForChain;
   }
@@ -509,7 +473,7 @@ export class BundleDataClient {
       // ok for this use case.
       const arweaveData = await this.loadArweaveData(pendingBundleBlockRanges);
       if (arweaveData === undefined) {
-        combinedRefunds.push(await this.getApproximateRefundsForBlockRange(chainIds, pendingBundleBlockRanges));
+        combinedRefunds.push(this.getApproximateRefundsForBlockRange(chainIds, pendingBundleBlockRanges));
       } else {
         const { bundleFillsV3, expiredDepositsToRefundV3 } = arweaveData;
         combinedRefunds.push(getRefundsFromBundle(bundleFillsV3, expiredDepositsToRefundV3));
@@ -524,7 +488,7 @@ export class BundleDataClient {
     // - Only look up fills sent after the pending bundle's end blocks
     // - Skip LP fee computations and just assume the relayer is being refunded the full deposit.inputAmount
     const start = performance.now();
-    combinedRefunds.push(await this.getApproximateRefundsForBlockRange(chainIds, widestBundleBlockRanges));
+    combinedRefunds.push(this.getApproximateRefundsForBlockRange(chainIds, widestBundleBlockRanges));
     this.logger.debug({
       at: "BundleDataClient#getNextBundleRefunds",
       message: `Loading approximate refunds for next bundle in ${Math.round(performance.now() - start) / 1000}s.`,
@@ -722,10 +686,6 @@ export class BundleDataClient {
       );
     };
 
-    const _depositIsExpired = (deposit: DepositWithBlock): boolean => {
-      return deposit.fillDeadline < bundleBlockTimestamps[deposit.destinationChainId][1];
-    };
-
     const _getFillStatusForDeposit = (deposit: Deposit, queryBlock: number): Promise<FillStatus> => {
       return spokePoolClients[deposit.destinationChainId].relayFillStatus(
         deposit,
@@ -788,22 +748,6 @@ export class BundleDataClient {
     const bundleDepositHashes: string[] = [];
     const olderDepositHashes: string[] = [];
 
-    // We use the following toggle to aid with the migration to pre-fills. The first bundle proposed using this
-    // pre-fill logic can double refund pre-fills that have already been filled in the last bundle, because the
-    // last bundle did not recognize a fill as a pre-fill. Therefore the developer should ensure that the version
-    // is bumped to the PRE_FILL_MIN_CONFIG_STORE_VERSION version before the first pre-fill bundle is proposed.
-    // To test the following bundle after this, the developer can set the FORCE_REFUND_PREFILLS environment variable
-    // to "true" simulate the bundle with pre-fill refunds.
-    // @todo Remove this logic once we have advanced sufficiently past the pre-fill migration.
-    const startBlockForMainnet = getBlockRangeForChain(
-      blockRangesForChains,
-      this.clients.hubPoolClient.chainId,
-      this.chainIdListForBundleEvaluationBlockNumbers
-    )[0];
-    const versionAtProposalBlock = this.clients.configStoreClient.getConfigStoreVersionForBlock(startBlockForMainnet);
-    const canRefundPrefills =
-      versionAtProposalBlock >= PRE_FILL_MIN_CONFIG_STORE_VERSION || process.env.FORCE_REFUND_PREFILLS === "true";
-
     let depositCounter = 0;
     for (const originChainId of allChainIds) {
       const originClient = spokePoolClients[originChainId];
@@ -817,13 +761,11 @@ export class BundleDataClient {
           // Only evaluate deposits that are in this bundle or in previous bundles. This means we cannot issue fill
           // refunds or slow fills here for deposits that are in future bundles (i.e. "pre-fills"). Instead, we'll
           // evaluate these pre-fills once the deposit is inside the "current" bundle block range.
-          if (deposit.blockNumber > originChainBlockRange[1] || isZeroValueDeposit(deposit)) {
+          if (isZeroValueDeposit(deposit) || deposit.blockNumber > originChainBlockRange[1]) {
             return;
           }
           depositCounter++;
           const relayDataHash = this.getRelayHashFromEvent(deposit);
-
-          // Duplicate deposits are treated like normal deposits.
           if (!v3RelayHashes[relayDataHash]) {
             v3RelayHashes[relayDataHash] = {
               deposit: deposit,
@@ -840,8 +782,6 @@ export class BundleDataClient {
             return;
           }
 
-          // Evaluate all expired deposits after fetching fill statuses,
-          // since we can't know for certain whether an expired deposit was filled a long time ago.
           if (deposit.blockNumber >= originChainBlockRange[0]) {
             bundleDepositHashes.push(relayDataHash);
             updateBundleDepositsV3(bundleDepositsV3, deposit);
@@ -885,8 +825,9 @@ export class BundleDataClient {
               (fill) => fill.blockNumber <= destinationChainBlockRange[1] && !isZeroValueFillOrSlowFillRequest(fill)
             ),
           async (fill) => {
-            fillCounter++;
             const relayDataHash = this.getRelayHashFromEvent(fill);
+            fillCounter++;
+
             if (v3RelayHashes[relayDataHash]) {
               if (!v3RelayHashes[relayDataHash].fill) {
                 assert(
@@ -894,60 +835,34 @@ export class BundleDataClient {
                   "Deposit should exist in relay hash dictionary."
                 );
                 // At this point, the v3RelayHashes entry already existed meaning that there is a matching deposit,
-                // so this fill can no longer be filled on-chain.
+                // so this fill is validated.
                 v3RelayHashes[relayDataHash].fill = fill;
                 if (fill.blockNumber >= destinationChainBlockRange[0]) {
-                  // `fill` will only possibly differ from `_fill` in the `relayer` field, which does not affect the
-                  // relay hash, so it is safe to modify.
-                  const fillToRefund = await verifyFillRepayment(
-                    fill,
-                    destinationClient.spokePool.provider,
-                    v3RelayHashes[relayDataHash].deposit!,
-                    allChainIds
-                  );
-                  if (!isDefined(fillToRefund)) {
-                    bundleInvalidFillsV3.push(fill);
-                    // We don't return here yet because we still need to mark unexecutable slow fill leaves
-                    // or duplicate deposits. However, we won't issue a fast fill refund.
-                  } else {
-                    v3RelayHashes[relayDataHash].fill = fillToRefund;
-                    validatedBundleV3Fills.push({
-                      ...fillToRefund,
-                      quoteTimestamp: v3RelayHashes[relayDataHash].deposit!.quoteTimestamp, // ! due to assert above
-                    });
-                  }
-
+                  validatedBundleV3Fills.push({
+                    ...fill,
+                    quoteTimestamp: v3RelayHashes[relayDataHash].deposit!.quoteTimestamp, // ! due to assert above
+                  });
                   // If fill replaced a slow fill request, then mark it as one that might have created an
                   // unexecutable slow fill. We can't know for sure until we check the slow fill request
                   // events.
                   // slow fill requests for deposits from or to lite chains are considered invalid
                   if (
                     fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill &&
-                    _canCreateSlowFillLeaf(v3RelayHashes[relayDataHash].deposit!)
+                    !v3RelayHashes[relayDataHash].deposit!.fromLiteChain &&
+                    !v3RelayHashes[relayDataHash].deposit!.toLiteChain
                   ) {
                     fastFillsReplacingSlowFills.push(relayDataHash);
                   }
-                  // Now that know this deposit has been filled on-chain, identify any duplicate deposits sent for this fill and refund
-                  // them, because they would not be refunded otherwise. These deposits can no longer expire and get
-                  // refunded as an expired deposit, and they won't trigger a pre-fill refund because the fill is
-                  // in this bundle. Pre-fill refunds only happen when deposits are sent in this bundle and the
-                  // fill is from a prior bundle.
-                  const duplicateDeposits = originClient.getDuplicateDeposits(v3RelayHashes[relayDataHash].deposit!);
-                  duplicateDeposits.forEach((duplicateDeposit) => {
-                    updateExpiredDepositsV3(expiredDepositsToRefundV3, duplicateDeposit);
-                  });
                 }
-              } else {
-                throw new Error("Duplicate fill detected.");
               }
               return;
             }
 
             // At this point, there is no relay hash dictionary entry for this fill, so we need to
-            // instantiate the entry. We won't modify the fill.relayer until we match it with a deposit.
+            // instantiate the entry.
             v3RelayHashes[relayDataHash] = {
               deposit: undefined,
-              fill,
+              fill: fill,
               slowFillRequest: undefined,
             };
 
@@ -975,42 +890,24 @@ export class BundleDataClient {
                 bundleInvalidFillsV3.push(fill);
               } else {
                 const matchedDeposit = historicalDeposit.deposit;
+                // @dev Since queryHistoricalDepositForFill validates the fill by checking individual
+                // object property values against the deposit's, we
+                // sanity check it here by comparing the full relay hashes. If there's an error here then the
+                // historical deposit query is not working as expected.
+                assert(this.getRelayHashFromEvent(matchedDeposit) === relayDataHash, "Relay hashes should match.");
+                validatedBundleV3Fills.push({
+                  ...fill,
+                  quoteTimestamp: matchedDeposit.quoteTimestamp,
+                });
                 v3RelayHashes[relayDataHash].deposit = matchedDeposit;
-
-                const fillToRefund = await verifyFillRepayment(
-                  fill,
-                  destinationClient.spokePool.provider,
-                  matchedDeposit,
-                  allChainIds
-                );
-                if (!isDefined(fillToRefund)) {
-                  bundleInvalidFillsV3.push(fill);
-                  // Don't return yet as we still need to mark down any unexecutable slow fill leaves
-                  // in case this fast fill replaced a slow fill request.
-                } else {
-                  // @dev Since queryHistoricalDepositForFill validates the fill by checking individual
-                  // object property values against the deposit's, we
-                  // sanity check it here by comparing the full relay hashes. If there's an error here then the
-                  // historical deposit query is not working as expected.
-                  assert(this.getRelayHashFromEvent(matchedDeposit) === relayDataHash, "Relay hashes should match.");
-                  validatedBundleV3Fills.push({
-                    ...fill,
-                    quoteTimestamp: matchedDeposit.quoteTimestamp,
-                  });
-                  v3RelayHashes[relayDataHash].fill = fillToRefund;
-                }
-
                 // slow fill requests for deposits from or to lite chains are considered invalid
                 if (
                   fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill &&
-                  _canCreateSlowFillLeaf(matchedDeposit)
+                  !matchedDeposit.fromLiteChain &&
+                  !matchedDeposit.toLiteChain
                 ) {
                   fastFillsReplacingSlowFills.push(relayDataHash);
                 }
-
-                // No need to check for duplicate deposits here since we would have seen them in memory if they
-                // had a non-infinite fill deadline, and duplicate deposits with infinite deadlines are impossible
-                // to send.
               }
             }
           }
@@ -1035,9 +932,7 @@ export class BundleDataClient {
                 v3RelayHashes[relayDataHash].slowFillRequest = slowFillRequest;
                 if (v3RelayHashes[relayDataHash].fill) {
                   // If there is a fill matching the relay hash, then this slow fill request can't be used
-                  // to create a slow fill for a filled deposit. This takes advantage of the fact that
-                  // slow fill requests must precede fills, so if there is a matching fill for this request's
-                  // relay data, then this slow fill will be unexecutable.
+                  // to create a slow fill for a filled deposit.
                   return;
                 }
                 assert(
@@ -1046,22 +941,22 @@ export class BundleDataClient {
                 );
                 // The ! is safe here because we've already checked that the deposit exists in the relay hash dictionary.
                 const matchedDeposit = v3RelayHashes[relayDataHash].deposit!;
+                if (!_canCreateSlowFillLeaf(matchedDeposit)) {
+                  return;
+                }
 
                 // If there is no fill matching the relay hash, then this might be a valid slow fill request
                 // that we should produce a slow fill leaf for. Check if the slow fill request is in the
                 // destination chain block range.
                 if (
                   slowFillRequest.blockNumber >= destinationChainBlockRange[0] &&
-                  _canCreateSlowFillLeaf(matchedDeposit) &&
                   // Deposit must not have expired in this bundle.
-                  !_depositIsExpired(matchedDeposit)
+                  slowFillRequest.fillDeadline >= bundleBlockTimestamps[destinationChainId][1]
                 ) {
                   // At this point, the v3RelayHashes entry already existed meaning that there is a matching deposit,
                   // so this slow fill request relay data is correct.
                   validatedBundleSlowFills.push(matchedDeposit);
                 }
-              } else {
-                throw new Error("Duplicate slow fill request detected.");
               }
               return;
             }
@@ -1108,7 +1003,7 @@ export class BundleDataClient {
               if (
                 !_canCreateSlowFillLeaf(matchedDeposit) ||
                 // Deposit must not have expired in this bundle.
-                _depositIsExpired(matchedDeposit)
+                slowFillRequest.fillDeadline < bundleBlockTimestamps[destinationChainId][1]
               ) {
                 return;
               }
@@ -1124,19 +1019,21 @@ export class BundleDataClient {
         // - Or, has the deposit expired in this bundle? If so, then we need to issue an expiry refund.
         // - And finally, has the deposit been slow filled? If so, then we need to issue a slow fill leaf
         //   for this "pre-slow-fill-request" if this request took place in a previous bundle.
+        const originBlockRange = getBlockRangeForChain(blockRangesForChains, originChainId, chainIds);
 
-        // @todo Only start refunding pre-fills and slow fill requests after a config store version is activated. We
-        // should remove this check once we've advanced far beyond the version bump block.
         await mapAsync(
           bundleDepositHashes.filter((depositHash) => {
             const { deposit } = v3RelayHashes[depositHash];
             return (
-              deposit && deposit.originChainId === originChainId && deposit.destinationChainId === destinationChainId
+              deposit &&
+              deposit.originChainId === originChainId &&
+              deposit.destinationChainId === destinationChainId &&
+              deposit.blockNumber >= originBlockRange[0] &&
+              deposit.blockNumber <= originBlockRange[1] &&
+              !isZeroValueDeposit(deposit)
             );
           }),
           async (depositHash) => {
-            // We don't need to call verifyFillRepayment() here to replace the fill.relayer because this value should already
-            // be overwritten because the deposit and fill both exist.
             const { deposit, fill, slowFillRequest } = v3RelayHashes[depositHash];
             if (!deposit) throw new Error("Deposit should exist in relay hash dictionary.");
 
@@ -1149,7 +1046,7 @@ export class BundleDataClient {
             // If fill exists in memory, then the only case in which we need to create a refund is if the
             // the fill occurred in a previous bundle. There are no expiry refunds for filled deposits.
             if (fill) {
-              if (canRefundPrefills && fill.blockNumber < destinationChainBlockRange[0] && !isSlowFill(fill)) {
+              if (!isSlowFill(fill) && fill.blockNumber < destinationChainBlockRange[0]) {
                 // If fill is in the current bundle then we can assume there is already a refund for it, so only
                 // include this pre fill if the fill is in an older bundle. If fill is after this current bundle, then
                 // we won't consider it, following the previous treatment of fills after the bundle block range.
@@ -1157,11 +1054,6 @@ export class BundleDataClient {
                   ...fill,
                   quoteTimestamp: deposit.quoteTimestamp,
                 });
-
-                // We don't refund duplicate deposits for pre-fill refunds because we are refunding the pre-fill instead
-                // using the duplicate deposited funds. We make an assumption that duplicate deposits for pre-fills
-                // are highly unlikely because deposits for pre-fills are designed to be sent by the pre-filler,
-                // so the depositor's approval should protect them from the pre-filler sending multiple deposits.
               }
               return;
             }
@@ -1172,12 +1064,11 @@ export class BundleDataClient {
             // we need to create a slow fill leaf for the deposit. The latter should only happen if the slow fill request
             // took place in a prior bundle otherwise we would have already created a slow fill leaf for it.
             if (slowFillRequest) {
-              if (_depositIsExpired(deposit)) {
+              if (deposit.fillDeadline < bundleBlockTimestamps[destinationChainId][1]) {
                 updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
               } else if (
-                canRefundPrefills &&
-                slowFillRequest.blockNumber < destinationChainBlockRange[0] &&
-                _canCreateSlowFillLeaf(deposit)
+                _canCreateSlowFillLeaf(deposit) &&
+                slowFillRequest.blockNumber < destinationChainBlockRange[0]
               ) {
                 validatedBundleSlowFills.push(deposit);
               }
@@ -1195,18 +1086,15 @@ export class BundleDataClient {
             if (fillStatus === FillStatus.Filled) {
               // We need to find the fill event to issue a refund to the right relayer and repayment chain,
               // or msg.sender if relayer address is invalid for the repayment chain.
-              const prefill = await this.findMatchingFillEvent(deposit, destinationClient);
-              assert(isDefined(prefill), `findFillEvent# Cannot find prefill: ${depositHash}`);
-              assert(this.getRelayHashFromEvent(prefill!) === depositHash, "Relay hashes should match.");
-              const verifiedFill = await verifyFillRepayment(
-                prefill!,
-                destinationClient.spokePool.provider,
+              const prefill = (await findFillEvent(
+                destinationClient.spokePool,
                 deposit,
-                allChainIds
-              );
-              if (canRefundPrefills && isDefined(verifiedFill) && !isSlowFill(verifiedFill)) {
+                destinationClient.deploymentBlock,
+                destinationClient.latestBlockSearched
+              )) as unknown as FillWithBlock;
+              if (!isSlowFill(prefill)) {
                 validatedBundleV3Fills.push({
-                  ...verifiedFill!,
+                  ...prefill,
                   quoteTimestamp: deposit.quoteTimestamp,
                 });
               }
@@ -1215,14 +1103,14 @@ export class BundleDataClient {
             // We don't check that fillDeadline >= bundleBlockTimestamps[destinationChainId][0] because
             // that would eliminate any deposits in this bundle with a very low fillDeadline like equal to 0
             // for example. Those should be included in this bundle of refunded deposits.
-            else if (_depositIsExpired(deposit)) {
+            else if (deposit.fillDeadline < bundleBlockTimestamps[destinationChainId][1]) {
               updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
             }
             // If slow fill requested, then issue a slow fill leaf for the deposit.
             else if (fillStatus === FillStatus.RequestedSlowFill) {
               // Input and Output tokens must be equivalent on the deposit for this to be slow filled.
               // Slow fill requests for deposits from or to lite chains are considered invalid
-              if (canRefundPrefills && _canCreateSlowFillLeaf(deposit)) {
+              if (_canCreateSlowFillLeaf(deposit)) {
                 // If deposit newly expired, then we can't create a slow fill leaf for it but we can
                 // create a deposit refund for it.
                 validatedBundleSlowFills.push(deposit);
@@ -1246,15 +1134,24 @@ export class BundleDataClient {
           }
           // We should never push fast fills involving lite chains here because slow fill requests for them are invalid:
           assert(
-            _canCreateSlowFillLeaf(deposit),
-            "fastFillsReplacingSlowFills should contain only deposits that can be slow filled"
+            !deposit.fromLiteChain && !deposit.toLiteChain,
+            "fastFillsReplacingSlowFills should not contain lite chain deposits"
           );
           const destinationBlockRange = getBlockRangeForChain(blockRangesForChains, destinationChainId, chainIds);
           if (
+            // If the slow fill request that was replaced by this fill was in an older bundle, then we don't
+            // need to check if the slow fill request was valid since we can assume all bundles in the past
+            // were validated. However, we might as well double check.
+            this.clients.hubPoolClient.areTokensEquivalent(
+              deposit.inputToken,
+              deposit.originChainId,
+              deposit.outputToken,
+              deposit.destinationChainId,
+              deposit.quoteBlockNumber
+            ) &&
             // If there is a slow fill request in this bundle that matches the relay hash, then there was no slow fill
             // created that would be considered excess.
-            !slowFillRequest ||
-            slowFillRequest.blockNumber < destinationBlockRange[0]
+            (!slowFillRequest || slowFillRequest.blockNumber < destinationBlockRange[0])
           ) {
             validatedBundleUnexecutableSlowFills.push(deposit);
           }
@@ -1283,7 +1180,7 @@ export class BundleDataClient {
         // If there is a valid fill that we saw matching this deposit, then it does not need a refund.
         !fill &&
         isDefined(deposit) && // Needed for TSC - we check this above.
-        _depositIsExpired(deposit) &&
+        deposit.fillDeadline < bundleBlockTimestamps[destinationChainId][1] &&
         deposit.fillDeadline >= bundleBlockTimestamps[destinationChainId][0] &&
         spokePoolClients[destinationChainId] !== undefined
       ) {
@@ -1299,7 +1196,8 @@ export class BundleDataClient {
         // If fill status is RequestedSlowFill, then we might need to mark down an unexecutable
         // slow fill that we're going to replace with an expired deposit refund.
         // If deposit cannot be slow filled, then exit early.
-        if (fillStatus !== FillStatus.RequestedSlowFill || !_canCreateSlowFillLeaf(deposit)) {
+        // slow fill requests for deposits from or to lite chains are considered invalid
+        if (fillStatus !== FillStatus.RequestedSlowFill || deposit.fromLiteChain || deposit.toLiteChain) {
           return;
         }
         // Now, check if there was a slow fill created for this deposit in a previous bundle which would now be
@@ -1308,9 +1206,21 @@ export class BundleDataClient {
 
         // If there is a slow fill request in this bundle, then the expired deposit refund will supercede
         // the slow fill request. If there is no slow fill request seen or its older than this bundle, then we can
-        // assume a slow fill leaf was created for it because of the previous _canCreateSlowFillLeaf check.
-        // The slow fill request was also sent before the fill deadline expired since we checked that above.
-        if (!slowFillRequest || slowFillRequest.blockNumber < destinationBlockRange[0]) {
+        // assume a slow fill leaf was created for it because its tokens are equivalent. The slow fill request was
+        // also sent before the fill deadline expired since we checked that above.
+        if (
+          // Since this deposit was requested for a slow fill in an older bundle at this point, we don't
+          // technically need to check if the slow fill request was valid since we can assume all bundles in the past
+          // were validated. However, we might as well double check.
+          this.clients.hubPoolClient.areTokensEquivalent(
+            deposit.inputToken,
+            deposit.originChainId,
+            deposit.outputToken,
+            deposit.destinationChainId,
+            deposit.quoteBlockNumber
+          ) &&
+          (!slowFillRequest || slowFillRequest.blockNumber < destinationBlockRange[0])
+        ) {
           validatedBundleUnexecutableSlowFills.push(deposit);
         }
       }
@@ -1375,7 +1285,7 @@ export class BundleDataClient {
         chainIds,
         associatedDeposit!.fromLiteChain
       );
-      updateBundleFillsV3(bundleFillsV3, fill, realizedLpFeePct, chainToSendRefundTo, repaymentToken, fill.relayer);
+      updateBundleFillsV3(bundleFillsV3, fill, realizedLpFeePct, chainToSendRefundTo, repaymentToken);
     });
     v3SlowFillLpFees.forEach(({ realizedLpFeePct: lpFeePct }, idx) => {
       const deposit = validatedBundleSlowFills[idx];
@@ -1423,24 +1333,8 @@ export class BundleDataClient {
   // keccak256 hash of the relay data, which can be used as input into the on-chain `fillStatuses()` function in the
   // spoke pool contract. However, this internal function is used to uniquely identify a bridging event
   // for speed since its easier to build a string from the event data than to hash it.
-  protected getRelayHashFromEvent(event: V3DepositWithBlock | V3FillWithBlock | SlowFillRequestWithBlock): string {
-    return `${event.depositor}-${event.recipient}-${event.exclusiveRelayer}-${event.inputToken}-${event.outputToken}-${
-      event.inputAmount
-    }-${event.outputAmount}-${event.originChainId}-${event.depositId.toString()}-${event.fillDeadline}-${
-      event.exclusivityDeadline
-    }-${event.message}-${event.destinationChainId}`;
-  }
-
-  protected async findMatchingFillEvent(
-    deposit: DepositWithBlock,
-    spokePoolClient: SpokePoolClient
-  ): Promise<FillWithBlock | undefined> {
-    return await findFillEvent(
-      spokePoolClient.spokePool,
-      deposit,
-      spokePoolClient.deploymentBlock,
-      spokePoolClient.latestBlockSearched
-    );
+  private getRelayHashFromEvent(event: V3DepositWithBlock | V3FillWithBlock | SlowFillRequestWithBlock): string {
+    return `${event.depositor}-${event.recipient}-${event.exclusiveRelayer}-${event.inputToken}-${event.outputToken}-${event.inputAmount}-${event.outputAmount}-${event.originChainId}-${event.depositId}-${event.fillDeadline}-${event.exclusivityDeadline}-${event.message}-${event.destinationChainId}`;
   }
 
   async getBundleBlockTimestamps(
@@ -1468,26 +1362,13 @@ export class BundleDataClient {
           // will usually be called in production with block ranges that were validated by
           // DataworkerUtils.blockRangesAreInvalidForSpokeClients.
           const startBlockForChain = Math.min(_startBlockForChain, spokePoolClient.latestBlockSearched);
-          // @dev Add 1 to the bundle end block. The thinking here is that there can be a gap between
-          // block timestamps in subsequent blocks. The bundle data client assumes that fill deadlines expire
-          // in exactly one bundle, therefore we must make sure that the bundle block timestamp for one bundle's
-          // end block is exactly equal to the bundle block timestamp for the next bundle's start block. This way
-          // there are no gaps in block timestamps between bundles.
-          const endBlockForChain = Math.min(_endBlockForChain + 1, spokePoolClient.latestBlockSearched);
-          const [startTime, _endTime] = [
+          const endBlockForChain = Math.min(_endBlockForChain, spokePoolClient.latestBlockSearched);
+          const [startTime, endTime] = [
             await spokePoolClient.getTimestampForBlock(startBlockForChain),
             await spokePoolClient.getTimestampForBlock(endBlockForChain),
           ];
-          // @dev similar to reasoning above to ensure no gaps between bundle block range timestamps and also
-          // no overlap, subtract 1 from the end time.
-          const endBlockDelta = endBlockForChain > startBlockForChain ? 1 : 0;
-          const endTime = Math.max(0, _endTime - endBlockDelta);
-
           // Sanity checks:
-          assert(
-            endTime >= startTime,
-            `End time for block ${endBlockForChain} should be greater than start time for block ${startBlockForChain}: ${endTime} >= ${startTime}.`
-          );
+          assert(endTime >= startTime, "End time should be greater than start time.");
           assert(
             startBlockForChain === 0 || startTime > 0,
             "Start timestamp must be greater than 0 if the start block is greater than 0."