@across-protocol/sdk 4.0.0-beta.9 → 4.0.1

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -33,6 +33,7 @@ import {
   getImpliedBundleBlockRanges,
   isSlowFill,
   mapAsync,
+  filterAsync,
   bnUint32Max,
   isZeroValueDeposit,
   findFillEvent,
@@ -49,10 +50,12 @@ import {
   getRefundsFromBundle,
   getWidestPossibleExpectedBlockRange,
   isChainDisabled,
+  isEvmRepaymentValid,
   PoolRebalanceRoot,
   prettyPrintV3SpokePoolEvents,
   V3DepositWithBlock,
   V3FillWithBlock,
+  verifyFillRepayment,
 } from "./utils";
 import { PRE_FILL_MIN_CONFIG_STORE_VERSION } from "../../constants";
 
@@ -87,12 +90,14 @@ function updateBundleFillsV3(
   fill: V3FillWithBlock,
   lpFeePct: BigNumber,
   repaymentChainId: number,
-  repaymentToken: string
+  repaymentToken: string,
+  repaymentAddress: 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(fill.repaymentChainId) && !isValidEvmAddress(fill.relayer)) {
-    return;
-  }
+  // We shouldn't pass any unrepayable fills into this function, so we perform an extra safety check.
+  assert(
+    chainIsEvm(repaymentChainId) && isEvmRepaymentValid(fill, repaymentChainId),
+    "validatedBundleV3Fills dictionary should only contain fills with valid repayment information"
+  );
   if (!dict?.[repaymentChainId]?.[repaymentToken]) {
     assign(dict, [repaymentChainId, repaymentToken], {
       fills: [],
@@ -102,19 +107,19 @@ function updateBundleFillsV3(
     });
   }
 
-  const bundleFill: BundleFillV3 = { ...fill, lpFeePct };
+  const bundleFill: BundleFillV3 = { ...fill, lpFeePct, relayer: repaymentAddress };
 
   // 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 = fill.inputAmount.mul(bundleFill.lpFeePct).div(fixedPointAdjustment);
+  const realizedLpFee = bundleFill.inputAmount.mul(bundleFill.lpFeePct).div(fixedPointAdjustment);
   refundObj.realizedLpFees = refundObj.realizedLpFees ? refundObj.realizedLpFees.add(realizedLpFee) : realizedLpFee;
 
   // Only fast fills get refunded.
-  if (!isSlowFill(fill)) {
-    const refundAmount = fill.inputAmount.mul(fixedPointAdjustment.sub(lpFeePct)).div(fixedPointAdjustment);
+  if (!isSlowFill(bundleFill)) {
+    const refundAmount = bundleFill.inputAmount.mul(fixedPointAdjustment.sub(lpFeePct)).div(fixedPointAdjustment);
     refundObj.totalRefundAmount = refundObj.totalRefundAmount
       ? refundObj.totalRefundAmount.add(refundAmount)
       : refundAmount;
@@ -122,10 +127,10 @@ function updateBundleFillsV3(
     // Instantiate dictionary if it doesn't exist.
     refundObj.refunds ??= {};
 
-    if (refundObj.refunds[fill.relayer]) {
-      refundObj.refunds[fill.relayer] = refundObj.refunds[fill.relayer].add(refundAmount);
+    if (refundObj.refunds[bundleFill.relayer]) {
+      refundObj.refunds[bundleFill.relayer] = refundObj.refunds[bundleFill.relayer].add(refundAmount);
     } else {
-      refundObj.refunds[fill.relayer] = refundAmount;
+      refundObj.refunds[bundleFill.relayer] = refundAmount;
     }
   }
 }
@@ -142,6 +147,9 @@ function updateBundleExcessSlowFills(
 }
 
 function updateBundleSlowFills(dict: BundleSlowFills, deposit: V3DepositWithBlock & { lpFeePct: BigNumber }): void {
+  if (chainIsEvm(deposit.destinationChainId) && !isValidEvmAddress(deposit.recipient)) {
+    return;
+  }
   const { destinationChainId, outputToken } = deposit;
   if (!dict?.[destinationChainId]?.[outputToken]) {
     assign(dict, [destinationChainId, outputToken], []);
@@ -245,7 +253,6 @@ export class BundleDataClient {
       bundleData: prettyPrintV3SpokePoolEvents(
         bundleData.bundleDepositsV3,
         bundleData.bundleFillsV3,
-        [], // Invalid fills are not persisted to Arweave.
         bundleData.bundleSlowFillsV3,
         bundleData.expiredDepositsToRefundV3,
         bundleData.unexecutableSlowFills
@@ -293,7 +300,7 @@ export class BundleDataClient {
     // so as not to affect this approximate refund count.
     const arweaveData = await this.loadArweaveData(bundleEvaluationBlockRanges);
     if (arweaveData === undefined) {
-      combinedRefunds = this.getApproximateRefundsForBlockRange(chainIds, bundleEvaluationBlockRanges);
+      combinedRefunds = await this.getApproximateRefundsForBlockRange(chainIds, bundleEvaluationBlockRanges);
     } else {
       const { bundleFillsV3, expiredDepositsToRefundV3 } = arweaveData;
       combinedRefunds = getRefundsFromBundle(bundleFillsV3, expiredDepositsToRefundV3);
@@ -314,56 +321,72 @@ export class BundleDataClient {
   }
 
   // @dev This helper function should probably be moved to the InventoryClient
-  getApproximateRefundsForBlockRange(chainIds: number[], blockRanges: number[][]): CombinedRefunds {
+  async getApproximateRefundsForBlockRange(chainIds: number[], blockRanges: number[][]): Promise<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
+      // @dev 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.
-      this.spokePoolClients[chainId]
-        .getFills()
-        .filter((fill) => {
-          if (fill.blockNumber < blockRanges[chainIndex][0] || fill.blockNumber > blockRanges[chainIndex][1]) {
-            return false;
-          }
+      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;
+        }
 
-          // 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);
-          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(
+        // 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.clients.hubPoolClient,
-            blockRanges,
-            this.chainIdListForBundleEvaluationBlockNumbers,
-            matchingDeposit!.fromLiteChain // Use ! because we've already asserted that matchingDeposit is defined.
+            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]))
           );
-          // 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);
-        });
+          if (!isDefined(validRepayment)) {
+            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);
+      });
     }
     return refundsForChain;
   }
@@ -407,7 +430,7 @@ export class BundleDataClient {
   async getLatestPoolRebalanceRoot(): Promise<{ root: PoolRebalanceRoot; blockRanges: number[][] }> {
     const { bundleData, blockRanges } = await this.getLatestProposedBundleData();
     const hubPoolClient = this.clients.hubPoolClient;
-    const root = await _buildPoolRebalanceRoot(
+    const root = _buildPoolRebalanceRoot(
       hubPoolClient.latestBlockSearched,
       blockRanges[0][1],
       bundleData.bundleDepositsV3,
@@ -490,7 +513,7 @@ export class BundleDataClient {
       // ok for this use case.
       const arweaveData = await this.loadArweaveData(pendingBundleBlockRanges);
       if (arweaveData === undefined) {
-        combinedRefunds.push(this.getApproximateRefundsForBlockRange(chainIds, pendingBundleBlockRanges));
+        combinedRefunds.push(await this.getApproximateRefundsForBlockRange(chainIds, pendingBundleBlockRanges));
       } else {
         const { bundleFillsV3, expiredDepositsToRefundV3 } = arweaveData;
         combinedRefunds.push(getRefundsFromBundle(bundleFillsV3, expiredDepositsToRefundV3));
@@ -505,7 +528,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(this.getApproximateRefundsForBlockRange(chainIds, widestBundleBlockRanges));
+    combinedRefunds.push(await 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.`,
@@ -672,6 +695,8 @@ export class BundleDataClient {
     const bundleDepositsV3: BundleDepositsV3 = {}; // Deposits in bundle block range.
     const bundleFillsV3: BundleFillsV3 = {}; // Fills to refund in bundle block range.
     const bundleInvalidFillsV3: V3FillWithBlock[] = []; // Fills that are not valid in this bundle.
+    const bundleUnrepayableFillsV3: V3FillWithBlock[] = []; // Fills that are not repayable in this bundle.
+    const bundleInvalidSlowFillRequests: SlowFillRequestWithBlock[] = []; // Slow fill requests that are not valid in this bundle.
     const bundleSlowFillsV3: BundleSlowFills = {}; // Deposits that we need to send slow fills
     // for in this bundle.
     const expiredDepositsToRefundV3: ExpiredDepositsToRefundV3 = {};
@@ -758,7 +783,7 @@ export class BundleDataClient {
         // Note: Since there are no partial fills in v3, there should only be one fill per relay hash.
         // Moreover, the SpokePool blocks multiple slow fill requests, so
         // there should also only be one slow fill request per relay hash.
-        deposit?: V3DepositWithBlock;
+        deposits?: V3DepositWithBlock[];
         fill?: V3FillWithBlock;
         slowFillRequest?: SlowFillRequestWithBlock;
       };
@@ -769,6 +794,11 @@ export class BundleDataClient {
     const bundleDepositHashes: string[] = [];
     const olderDepositHashes: string[] = [];
 
+    const decodeBundleDepositHash = (depositHash: string): { relayDataHash: string; index: number } => {
+      const [relayDataHash, i] = depositHash.split("@");
+      return { relayDataHash, index: Number(i) };
+    };
+
     // 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
@@ -785,7 +815,8 @@ export class BundleDataClient {
     const canRefundPrefills =
       versionAtProposalBlock >= PRE_FILL_MIN_CONFIG_STORE_VERSION || process.env.FORCE_REFUND_PREFILLS === "true";
 
-    let depositCounter = 0;
+    // Prerequisite step: Load all deposit events from the current or older bundles into the v3RelayHashes dictionary
+    // for convenient matching with fills.
     for (const originChainId of allChainIds) {
       const originClient = spokePoolClients[originChainId];
       const originChainBlockRange = getBlockRangeForChain(blockRangesForChains, originChainId, chainIds);
@@ -795,50 +826,59 @@ export class BundleDataClient {
           continue;
         }
         originClient.getDepositsForDestinationChainWithDuplicates(destinationChainId).forEach((deposit) => {
-          // 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)) {
             return;
           }
-          depositCounter++;
           const relayDataHash = this.getRelayHashFromEvent(deposit);
 
-          // Duplicate deposits are treated like normal deposits.
           if (!v3RelayHashes[relayDataHash]) {
             v3RelayHashes[relayDataHash] = {
-              deposit: deposit,
+              deposits: [deposit],
               fill: undefined,
               slowFillRequest: undefined,
             };
+          } else {
+            v3RelayHashes[relayDataHash].deposits!.push(deposit);
           }
 
-          // Once we've saved the deposit hash into v3RelayHashes, then we can exit early here if the inputAmount
-          // is 0 because there can be no expired amount to refund and no unexecutable slow fill amount to return
-          // if this deposit did expire. Input amount can only be zero at this point if the message is non-empty,
-          // but the message doesn't matter for expired deposits and unexecutable slow fills.
-          if (deposit.inputAmount.eq(0)) {
-            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.
+          // Account for duplicate deposits by concatenating the relayDataHash with the count of the number of times
+          // we have seen it so far.
+          const newBundleDepositHash = `${relayDataHash}@${v3RelayHashes[relayDataHash].deposits!.length - 1}`;
+          const decodedBundleDepositHash = decodeBundleDepositHash(newBundleDepositHash);
+          assert(
+            decodedBundleDepositHash.relayDataHash === relayDataHash &&
+              decodedBundleDepositHash.index === v3RelayHashes[relayDataHash].deposits!.length - 1,
+            "Not using correct bundle deposit hash key"
+          );
           if (deposit.blockNumber >= originChainBlockRange[0]) {
-            bundleDepositHashes.push(relayDataHash);
+            bundleDepositHashes.push(newBundleDepositHash);
             updateBundleDepositsV3(bundleDepositsV3, deposit);
           } else if (deposit.blockNumber < originChainBlockRange[0]) {
-            olderDepositHashes.push(relayDataHash);
+            olderDepositHashes.push(newBundleDepositHash);
           }
         });
       }
     }
     this.logger.debug({
       at: "BundleDataClient#loadData",
-      message: `Processed ${depositCounter} deposits in ${performance.now() - start}ms.`,
+      message: `Processed ${bundleDepositHashes.length + olderDepositHashes.length} deposits in ${
+        performance.now() - start
+      }ms.`,
     });
     start = performance.now();
 
-    // Process fills now that we've populated relay hash dictionary with deposits:
+    // Process fills and maintain the following the invariants:
+    // - Every single fill whose type is not SlowFill in the bundle block range whose relay data matches
+    // with a deposit in the same or an older range produces a refund to the filler,
+    // unless the specified filler address cannot be repaid on the repayment chain.
+    // - Fills can match with duplicate deposits, so for every matched fill whose type is not SlowFill
+    // in the bundle block range, produce a refund to the filler for each matched deposit.
+    // - For every SlowFill in the block range that matches with multiple deposits, produce a refund to the depositor
+    // for every deposit except except the first.
+
+    // Assumptions about fills:
+    // - Duplicate fills for the same relay data hash are impossible to send.
+    // - Fills can only be sent before the deposit's fillDeadline.
     const validatedBundleV3Fills: (V3FillWithBlock & { quoteTimestamp: number })[] = [];
     const validatedBundleSlowFills: V3DepositWithBlock[] = [];
     const validatedBundleUnexecutableSlowFills: V3DepositWithBlock[] = [];
@@ -852,9 +892,8 @@ export class BundleDataClient {
 
         const destinationClient = spokePoolClients[destinationChainId];
         const destinationChainBlockRange = getBlockRangeForChain(blockRangesForChains, destinationChainId, chainIds);
+        const originChainBlockRange = getBlockRangeForChain(blockRangesForChains, originChainId, chainIds);
 
-        // Keep track of fast fills that replaced slow fills, which we'll use to create "unexecutable" slow fills
-        // if the slow fill request was sent in a prior bundle.
         const fastFillsReplacingSlowFills: string[] = [];
         await forEachAsync(
           destinationClient
@@ -866,47 +905,79 @@ export class BundleDataClient {
               (fill) => fill.blockNumber <= destinationChainBlockRange[1] && !isZeroValueFillOrSlowFillRequest(fill)
             ),
           async (fill) => {
-            const relayDataHash = this.getRelayHashFromEvent(fill);
             fillCounter++;
-
+            const relayDataHash = this.getRelayHashFromEvent(fill);
             if (v3RelayHashes[relayDataHash]) {
               if (!v3RelayHashes[relayDataHash].fill) {
                 assert(
-                  isDefined(v3RelayHashes[relayDataHash].deposit),
+                  isDefined(v3RelayHashes[relayDataHash].deposits) && v3RelayHashes[relayDataHash].deposits!.length > 0,
                   "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 is validated.
                 v3RelayHashes[relayDataHash].fill = fill;
                 if (fill.blockNumber >= destinationChainBlockRange[0]) {
-                  validatedBundleV3Fills.push({
-                    ...fill,
-                    quoteTimestamp: v3RelayHashes[relayDataHash].deposit!.quoteTimestamp, // ! due to assert above
-                  });
+                  const fillToRefund = await verifyFillRepayment(
+                    fill,
+                    destinationClient.spokePool.provider,
+                    v3RelayHashes[relayDataHash].deposits![0],
+                    allChainIds
+                  );
+                  if (!isDefined(fillToRefund)) {
+                    bundleUnrepayableFillsV3.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].deposits![0].quoteTimestamp,
+                    });
+
+                    // Now that we know this deposit has been filled on-chain, identify any duplicate deposits
+                    // sent for this fill and refund them to the filler, because this value would not be paid out
+                    // 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. Paying out the filler keeps the behavior consistent for how
+                    // we deal with duplicate deposits regardless if the deposit is matched with a pre-fill or
+                    // a current bundle fill.
+                    const duplicateDeposits = v3RelayHashes[relayDataHash].deposits!.slice(1);
+                    duplicateDeposits.forEach((duplicateDeposit) => {
+                      if (isSlowFill(fill)) {
+                        updateExpiredDepositsV3(expiredDepositsToRefundV3, duplicateDeposit);
+                      } else {
+                        validatedBundleV3Fills.push({
+                          ...fillToRefund,
+                          quoteTimestamp: duplicateDeposit.quoteTimestamp,
+                        });
+                      }
+                    });
+                  }
+
                   // 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!)
+                    _canCreateSlowFillLeaf(v3RelayHashes[relayDataHash].deposits![0])
                   ) {
                     fastFillsReplacingSlowFills.push(relayDataHash);
                   }
                 }
+              } 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.
+            // instantiate the entry. We won't modify the fill.relayer until we match it with a deposit.
             v3RelayHashes[relayDataHash] = {
-              deposit: undefined,
-              fill: fill,
+              deposits: undefined,
+              fill,
               slowFillRequest: undefined,
             };
 
-            // TODO: We might be able to remove the following historical query once we deprecate the deposit()
+            // TODO: We can remove the following historical query once we deprecate the deposit()
             // function since there won't be any old, unexpired deposits anymore assuming the spoke pool client
             // lookbacks have been validated, which they should be before we run this function.
 
@@ -922,18 +993,6 @@ export class BundleDataClient {
                 bundleInvalidFillsV3.push(fill);
                 return;
               }
-              // If the fill's repayment address is not a valid EVM address and the repayment chain is an EVM chain, the fill is invalid.
-              if (chainIsEvm(fill.repaymentChainId) && !isValidEvmAddress(fill.relayer)) {
-                const fillTransaction = await originClient.spokePool.provider.getTransaction(fill.transactionHash);
-                const originRelayer = fillTransaction.from;
-                // Repayment chain is still an EVM chain, but the msg.sender is a bytes32 address, so the fill is invalid.
-                if (!isValidEvmAddress(originRelayer)) {
-                  bundleInvalidFillsV3.push(fill);
-                  return;
-                }
-                // Otherwise, assume the relayer to be repaid is the msg.sender.
-                fill.relayer = originRelayer;
-              }
               // If deposit is using the deterministic relay hash feature, then the following binary search-based
               // algorithm will not work. However, it is impossible to emit an infinite fill deadline using
               // the unsafeDepositV3 function so there is no need to catch the special case.
@@ -942,17 +1001,40 @@ 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;
-                // slow fill requests for deposits from or to lite chains are considered invalid
+                // If deposit is in a following bundle, then this fill will have to be refunded once that deposit
+                // is in the current bundle.
+                if (matchedDeposit.blockNumber > originChainBlockRange[1]) {
+                  bundleInvalidFillsV3.push(fill);
+                  return;
+                }
+                v3RelayHashes[relayDataHash].deposits = [matchedDeposit];
+
+                const fillToRefund = await verifyFillRepayment(
+                  fill,
+                  destinationClient.spokePool.provider,
+                  matchedDeposit,
+                  allChainIds
+                );
+                if (!isDefined(fillToRefund)) {
+                  bundleUnrepayableFillsV3.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({
+                    ...fillToRefund,
+                    quoteTimestamp: matchedDeposit.quoteTimestamp,
+                  });
+                  v3RelayHashes[relayDataHash].fill = fillToRefund;
+
+                  // No need to check for duplicate deposits here since duplicate deposits with
+                  // infinite deadlines are impossible to send via unsafeDeposit().
+                }
+
                 if (
                   fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill &&
                   _canCreateSlowFillLeaf(matchedDeposit)
@@ -964,8 +1046,14 @@ export class BundleDataClient {
           }
         );
 
-        // Process slow fill requests. One invariant we need to maintain is that we cannot create slow fill requests
-        // for deposits that would expire in this bundle.
+        // Process slow fill requests and produce slow fill leaves while maintaining the following the invariants:
+        // - Slow fill leaves cannot be produced for deposits that have expired in this bundle.
+        // - Slow fill leaves cannot be produced for deposits that have been filled.
+
+        // Assumptions about fills:
+        // - Duplicate slow fill requests for the same relay data hash are impossible to send.
+        // - Slow fill requests can only be sent before the deposit's fillDeadline.
+        // - Slow fill requests for a deposit that has been filled.
         await forEachAsync(
           destinationClient
             .getSlowFillRequestsForOriginChain(originChainId)
@@ -978,46 +1066,40 @@ export class BundleDataClient {
 
             if (v3RelayHashes[relayDataHash]) {
               if (!v3RelayHashes[relayDataHash].slowFillRequest) {
-                // At this point, the v3RelayHashes entry already existed meaning that there is either a matching
-                // fill or deposit.
                 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.
+                  // Exiting here assumes that slow fill requests must precede fills, so if there was a fill
+                  // following this slow fill request, then we would have already seen it. We don't need to check
+                  // for a fill older than this slow fill request.
                   return;
                 }
                 assert(
-                  isDefined(v3RelayHashes[relayDataHash].deposit),
+                  isDefined(v3RelayHashes[relayDataHash].deposits) && v3RelayHashes[relayDataHash].deposits!.length > 0,
                   "Deposit should exist in relay hash dictionary."
                 );
-                // The ! is safe here because we've already checked that the deposit exists in the relay hash dictionary.
-                const matchedDeposit = v3RelayHashes[relayDataHash].deposit!;
+                const matchedDeposit = v3RelayHashes[relayDataHash].deposits![0];
 
-                // 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)
                 ) {
-                  // 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;
             }
 
             // Instantiate dictionary if there is neither a deposit nor fill matching it.
             v3RelayHashes[relayDataHash] = {
-              deposit: undefined,
+              deposits: undefined,
               fill: undefined,
               slowFillRequest: slowFillRequest,
             };
 
-            // TODO: We might be able to remove the following historical query once we deprecate the deposit()
+            // TODO: We can remove the following historical query once we deprecate the deposit()
             // function since there won't be any old, unexpired deposits anymore assuming the spoke pool client
             // lookbacks have been validated, which they should be before we run this function.
 
@@ -1029,16 +1111,23 @@ export class BundleDataClient {
             // want to perform a binary search lookup for it because the deposit ID is "unsafe" and cannot be
             // found using such a method) because infinite fill deadlines cannot be produced from the unsafeDepositV3()
             // function.
-            if (
-              slowFillRequest.blockNumber >= destinationChainBlockRange[0] &&
-              INFINITE_FILL_DEADLINE.eq(slowFillRequest.fillDeadline)
-            ) {
+            if (slowFillRequest.blockNumber >= destinationChainBlockRange[0]) {
+              if (!INFINITE_FILL_DEADLINE.eq(slowFillRequest.fillDeadline)) {
+                bundleInvalidSlowFillRequests.push(slowFillRequest);
+                return;
+              }
               const historicalDeposit = await queryHistoricalDepositForFill(originClient, slowFillRequest);
               if (!historicalDeposit.found) {
-                // TODO: Invalid slow fill request. Maybe worth logging.
+                bundleInvalidSlowFillRequests.push(slowFillRequest);
                 return;
               }
               const matchedDeposit: V3DepositWithBlock = historicalDeposit.deposit;
+              // If deposit is in a following bundle, then this slow fill request will have to be created
+              // once that deposit is in the current bundle.
+              if (matchedDeposit.blockNumber > originChainBlockRange[1]) {
+                bundleInvalidSlowFillRequests.push(slowFillRequest);
+                return;
+              }
               // @dev Since queryHistoricalDepositForFill validates the slow fill request 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
@@ -1047,13 +1136,9 @@ export class BundleDataClient {
                 this.getRelayHashFromEvent(matchedDeposit) === relayDataHash,
                 "Deposit relay hashes should match."
               );
-              v3RelayHashes[relayDataHash].deposit = matchedDeposit;
+              v3RelayHashes[relayDataHash].deposits = [matchedDeposit];
 
-              if (
-                !_canCreateSlowFillLeaf(matchedDeposit) ||
-                // Deposit must not have expired in this bundle.
-                _depositIsExpired(matchedDeposit)
-              ) {
+              if (!_canCreateSlowFillLeaf(matchedDeposit) || _depositIsExpired(matchedDeposit)) {
                 return;
               }
               validatedBundleSlowFills.push(matchedDeposit);
@@ -1061,126 +1146,143 @@ export class BundleDataClient {
           }
         );
 
-        // Deposits can be submitted an arbitrary amount of time after matching fills and slow fill requests.
-        // Therefore, let's go through each deposit in this bundle again and check a few things in order:
-        // - Has the deposit been filled ? If so, then we need to issue a relayer refund for
-        //   this "pre-fill" if the fill took place in a previous bundle.
-        // - 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.
-
-        // @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
-            );
-          }),
-          async (depositHash) => {
-            const { deposit, fill, slowFillRequest } = v3RelayHashes[depositHash];
-            if (!deposit) throw new Error("Deposit should exist in relay hash dictionary.");
-
-            // We are willing to refund a pre-fill multiple times for each duplicate deposit.
-            // This is because a duplicate deposit for a pre-fill cannot get
-            // refunded to the depositor anymore because its fill status on-chain has changed to Filled. Therefore
-            // any duplicate deposits result in a net loss of funds for the depositor and effectively pay out
-            // the pre-filler.
-
-            // 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 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.
+        // Process deposits and maintain the following invariants:
+        // - Deposits matching fills that are not type SlowFill from previous bundle block ranges should produce
+        // refunds for those fills.
+        // - Deposits matching fills that are type SlowFill from previous bundle block ranges should be refunded to the
+        // depositor.
+        // - All deposits expiring in this bundle, even those sent in prior bundle block ranges, should be refunded
+        // to the depositor.
+        // - An expired deposit cannot be refunded if the deposit was filled.
+        // - If a deposit from a prior bundle expired in this bundle, had a slow fill request created for it
+        // in a prior bundle, and has not been filled yet, then an unexecutable slow fill leaf has been created
+        // and needs to be refunded to the HubPool.
+        // - Deposits matching slow fill requests from previous bundle block ranges should produce slow fills
+        // if the deposit has not been filled.
+
+        // Assumptions:
+        // - If the deposit has a matching fill or slow fill request in the bundle then we have already stored
+        // it in the relay hashes dictionary.
+        // - We've created refunds for all fills in this bundle matching a deposit.
+        // - We've created slow fill leaves for all slow fill requests in this bundle matching an unfilled deposit.
+        // - Deposits for the same relay data hash can be sent an arbitrary amount of times.
+        // - Deposits can be sent an arbitrary amount of time after a fill has been sent for the matching relay data.
+        await mapAsync(bundleDepositHashes, async (depositHash) => {
+          const { relayDataHash, index } = decodeBundleDepositHash(depositHash);
+          const { deposits, fill, slowFillRequest } = v3RelayHashes[relayDataHash];
+          if (!deposits || deposits.length === 0) {
+            throw new Error("Deposits should exist in relay hash dictionary.");
+          }
+          const deposit = deposits[index];
+          if (!deposit) throw new Error("Deposit should exist in relay hash dictionary.");
+          if (deposit.originChainId !== originChainId || deposit.destinationChainId !== destinationChainId) {
+            return;
+          }
+
+          // 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) {
+            if (canRefundPrefills && fill.blockNumber < destinationChainBlockRange[0]) {
+              const fillToRefund = await verifyFillRepayment(
+                fill,
+                destinationClient.spokePool.provider,
+                v3RelayHashes[relayDataHash].deposits![0],
+                allChainIds
+              );
+              if (!isDefined(fillToRefund)) {
+                bundleUnrepayableFillsV3.push(fill);
+              } else if (!isSlowFill(fill)) {
+                v3RelayHashes[relayDataHash].fill = fillToRefund;
                 validatedBundleV3Fills.push({
-                  ...fill,
+                  ...fillToRefund,
                   quoteTimestamp: deposit.quoteTimestamp,
                 });
+              } else {
+                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
               }
-              return;
             }
+            return;
+          }
 
-            // If a slow fill request exists in memory, then we know the deposit has not been filled because fills
-            // must follow slow fill requests and we would have seen the fill already if it existed. Therefore,
-            // we can conclude that either the deposit has expired and we need to create a deposit expiry refund, or
-            // 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)) {
-                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
-              } else if (
-                canRefundPrefills &&
-                slowFillRequest.blockNumber < destinationChainBlockRange[0] &&
-                _canCreateSlowFillLeaf(deposit)
-              ) {
-                validatedBundleSlowFills.push(deposit);
-              }
-              return;
+          // If a slow fill request exists in memory, then we know the deposit has not been filled because fills
+          // must follow slow fill requests and we would have seen the fill already if it existed.,
+          // We can conclude that either the deposit has expired or we need to create a slow fill leaf for the
+          // deposit because it has not been filled. Slow fill leaves were already created for requests sent
+          // in the current bundle so only create new slow fill leaves for prior bundle deposits.
+          if (slowFillRequest) {
+            if (_depositIsExpired(deposit)) {
+              updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
+            } else if (
+              canRefundPrefills &&
+              slowFillRequest.blockNumber < destinationChainBlockRange[0] &&
+              _canCreateSlowFillLeaf(deposit) &&
+              validatedBundleSlowFills.every((d) => this.getRelayHashFromEvent(d) !== relayDataHash)
+            ) {
+              validatedBundleSlowFills.push(deposit);
             }
+            return;
+          }
 
-            // So at this point in the code, there is no fill or slow fill request in memory for this deposit.
-            // We need to check its fill status on-chain to figure out whether to issue a refund or a slow fill leaf.
-            // We can assume at this point that all fills or slow fill requests, if found, were in previous bundles
-            // because the spoke pool client lookback would have returned this entire bundle of events and stored
-            // them into the relay hash dictionary.
-            const fillStatus = await _getFillStatusForDeposit(deposit, destinationChainBlockRange[1]);
-
-            // If deposit was filled, then we need to issue a refund for it.
-            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 findFillEvent(
-                destinationClient.spokePool,
+          // So at this point in the code, there is no fill or slow fill request in memory for this deposit.
+          // We need to check its fill status on-chain to figure out whether to issue a refund or a slow fill leaf.
+          // We can assume at this point that all fills or slow fill requests, if found, were in previous bundles
+          // because the spoke pool client lookback would have returned this entire bundle of events and stored
+          // them into the relay hash dictionary.
+          const fillStatus = await _getFillStatusForDeposit(deposit, destinationChainBlockRange[1]);
+          if (fillStatus === FillStatus.Filled) {
+            // We don't need to verify the fill block is before the bundle end block on the destination chain because
+            // we queried the fillStatus at the end block. Therefore, if the fill took place after the end block,
+            // then we wouldn't be in this branch of the code.
+            const prefill = await this.findMatchingFillEvent(deposit, destinationClient);
+            assert(isDefined(prefill), `findFillEvent# Cannot find prefill: ${relayDataHash}`);
+            assert(this.getRelayHashFromEvent(prefill!) === relayDataHash, "Relay hashes should match.");
+            if (canRefundPrefills) {
+              const verifiedFill = await verifyFillRepayment(
+                prefill!,
+                destinationClient.spokePool.provider,
                 deposit,
-                destinationClient.deploymentBlock,
-                destinationClient.latestBlockSearched
-              )) as unknown as FillWithBlock;
-              if (canRefundPrefills && !isSlowFill(prefill)) {
+                allChainIds
+              );
+              if (!isDefined(verifiedFill)) {
+                bundleUnrepayableFillsV3.push(prefill!);
+              } else if (!isSlowFill(verifiedFill)) {
                 validatedBundleV3Fills.push({
-                  ...prefill,
+                  ...verifiedFill!,
                   quoteTimestamp: deposit.quoteTimestamp,
                 });
+              } else {
+                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
               }
             }
-            // If deposit is not filled and its newly expired, we can create a deposit refund for it.
-            // 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)) {
-              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 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);
-              }
+          } else if (_depositIsExpired(deposit)) {
+            updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
+          } else if (
+            fillStatus === FillStatus.RequestedSlowFill &&
+            // Don't create duplicate slow fill requests for the same deposit.
+            validatedBundleSlowFills.every((d) => this.getRelayHashFromEvent(d) !== relayDataHash)
+          ) {
+            if (canRefundPrefills && _canCreateSlowFillLeaf(deposit)) {
+              validatedBundleSlowFills.push(deposit);
             }
           }
-        );
+        });
 
         // For all fills that came after a slow fill request, we can now check if the slow fill request
         // was a valid one and whether it was created in a previous bundle. If so, then it created a slow fill
         // leaf that is now unexecutable.
         fastFillsReplacingSlowFills.forEach((relayDataHash) => {
-          const { deposit, slowFillRequest, fill } = v3RelayHashes[relayDataHash];
+          const { deposits, slowFillRequest, fill } = v3RelayHashes[relayDataHash];
           assert(
             fill?.relayExecutionInfo.fillType === FillType.ReplacedSlowFill,
             "Fill type should be ReplacedSlowFill."
           );
           // Needed for TSC - are implicitely checking that deposit exists by making it to this point.
-          if (!deposit) {
+          if (!deposits || deposits.length < 1) {
             throw new Error("Deposit should exist in relay hash dictionary.");
           }
           // We should never push fast fills involving lite chains here because slow fill requests for them are invalid:
           assert(
-            _canCreateSlowFillLeaf(deposit),
+            _canCreateSlowFillLeaf(deposits[0]),
             "fastFillsReplacingSlowFills should contain only deposits that can be slow filled"
           );
           const destinationBlockRange = getBlockRangeForChain(blockRangesForChains, destinationChainId, chainIds);
@@ -1190,7 +1292,7 @@ export class BundleDataClient {
             !slowFillRequest ||
             slowFillRequest.blockNumber < destinationBlockRange[0]
           ) {
-            validatedBundleUnexecutableSlowFills.push(deposit);
+            validatedBundleUnexecutableSlowFills.push(deposits[0]);
           }
         });
       }
@@ -1204,15 +1306,19 @@ export class BundleDataClient {
     // For all deposits older than this bundle, we need to check if they expired in this bundle and if they did,
     // whether there was a slow fill created for it in a previous bundle that is now unexecutable and replaced
     // by a new expired deposit refund.
-    await forEachAsync(olderDepositHashes, async (relayDataHash) => {
-      const { deposit, slowFillRequest, fill } = v3RelayHashes[relayDataHash];
-      assert(isDefined(deposit), "Deposit should exist in relay hash dictionary.");
-      const { destinationChainId } = deposit!;
+    await forEachAsync(olderDepositHashes, async (depositHash) => {
+      const { relayDataHash, index } = decodeBundleDepositHash(depositHash);
+      const { deposits, slowFillRequest, fill } = v3RelayHashes[relayDataHash];
+      if (!deposits || deposits.length < 1) {
+        throw new Error("Deposit should exist in relay hash dictionary.");
+      }
+      const deposit = deposits[index];
+      const { destinationChainId } = deposit;
       const destinationBlockRange = getBlockRangeForChain(blockRangesForChains, destinationChainId, chainIds);
 
       // Only look for deposits that were mined before this bundle and that are newly expired.
       // If the fill deadline is lower than the bundle start block on the destination chain, then
-      // we should assume it was marked "newly expired" and refunded in a previous bundle.
+      // we should assume it was refunded in a previous bundle.
       if (
         // If there is a valid fill that we saw matching this deposit, then it does not need a refund.
         !fill &&
@@ -1256,7 +1362,7 @@ export class BundleDataClient {
       validatedBundleV3Fills.length > 0
         ? this.clients.hubPoolClient.batchComputeRealizedLpFeePct(
             validatedBundleV3Fills.map((fill) => {
-              const matchedDeposit = v3RelayHashes[this.getRelayHashFromEvent(fill)].deposit;
+              const matchedDeposit = v3RelayHashes[this.getRelayHashFromEvent(fill)].deposits![0];
               assert(isDefined(matchedDeposit), "Deposit should exist in relay hash dictionary.");
               const { chainToSendRefundTo: paymentChainId } = getRefundInformationFromFill(
                 fill,
@@ -1300,7 +1406,7 @@ export class BundleDataClient {
     });
     v3FillLpFees.forEach(({ realizedLpFeePct }, idx) => {
       const fill = validatedBundleV3Fills[idx];
-      const associatedDeposit = v3RelayHashes[this.getRelayHashFromEvent(fill)].deposit;
+      const associatedDeposit = v3RelayHashes[this.getRelayHashFromEvent(fill)].deposits![0];
       assert(isDefined(associatedDeposit), "Deposit should exist in relay hash dictionary.");
       const { chainToSendRefundTo, repaymentToken } = getRefundInformationFromFill(
         fill,
@@ -1309,10 +1415,19 @@ export class BundleDataClient {
         chainIds,
         associatedDeposit!.fromLiteChain
       );
-      updateBundleFillsV3(bundleFillsV3, fill, realizedLpFeePct, chainToSendRefundTo, repaymentToken);
+      updateBundleFillsV3(bundleFillsV3, fill, realizedLpFeePct, chainToSendRefundTo, repaymentToken, fill.relayer);
     });
     v3SlowFillLpFees.forEach(({ realizedLpFeePct: lpFeePct }, idx) => {
       const deposit = validatedBundleSlowFills[idx];
+      // We should not create slow fill leaves for duplicate deposit hashes and we should only create a slow
+      // fill leaf for the first deposit (the quote timestamp of the deposit determines the LP fee, so its
+      // important we pick out the correct deposit). Deposits are pushed into validatedBundleSlowFills in ascending
+      // order so the following slice will only match the first deposit.
+      const relayDataHash = this.getRelayHashFromEvent(deposit);
+      if (validatedBundleSlowFills.slice(0, idx).some((d) => this.getRelayHashFromEvent(d) === relayDataHash)) {
+        return;
+      }
+      assert(!_depositIsExpired(deposit), "Cannot create slow fill leaf for expired deposit.");
       updateBundleSlowFills(bundleSlowFillsV3, { ...deposit, lpFeePct });
     });
     v3UnexecutableSlowFillLpFees.forEach(({ realizedLpFeePct: lpFeePct }, idx) => {
@@ -1323,7 +1438,6 @@ export class BundleDataClient {
     const v3SpokeEventsReadable = prettyPrintV3SpokePoolEvents(
       bundleDepositsV3,
       bundleFillsV3,
-      bundleInvalidFillsV3,
       bundleSlowFillsV3,
       expiredDepositsToRefundV3,
       unexecutableSlowFills
@@ -1332,12 +1446,30 @@ export class BundleDataClient {
     if (bundleInvalidFillsV3.length > 0) {
       this.logger.debug({
         at: "BundleDataClient#loadData",
-        message: "Finished loading V3 spoke pool data and found some invalid V3 fills in range",
+        message: "Finished loading V3 spoke pool data and found some invalid fills in range",
         blockRangesForChains,
         bundleInvalidFillsV3,
       });
     }
 
+    if (bundleUnrepayableFillsV3.length > 0) {
+      this.logger.debug({
+        at: "BundleDataClient#loadData",
+        message: "Finished loading V3 spoke pool data and found some unrepayable fills in range",
+        blockRangesForChains,
+        bundleUnrepayableFillsV3,
+      });
+    }
+
+    if (bundleInvalidSlowFillRequests.length > 0) {
+      this.logger.debug({
+        at: "BundleDataClient#loadData",
+        message: "Finished loading V3 spoke pool data and found some invalid slow fill requests in range",
+        blockRangesForChains,
+        bundleInvalidSlowFillRequests,
+      });
+    }
+
     this.logger.debug({
       at: "BundleDataClient#loadDataFromScratch",
       message: `Computed bundle data in ${Math.round(performance.now() - start) / 1000}s.`,
@@ -1357,7 +1489,7 @@ 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.
-  private getRelayHashFromEvent(event: V3DepositWithBlock | V3FillWithBlock | SlowFillRequestWithBlock): string {
+  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}-${
@@ -1365,6 +1497,18 @@ export class BundleDataClient {
     }-${event.message}-${event.destinationChainId}`;
   }
 
+  protected async findMatchingFillEvent(
+    deposit: DepositWithBlock,
+    spokePoolClient: SpokePoolClient
+  ): Promise<FillWithBlock | undefined> {
+    return await findFillEvent(
+      spokePoolClient.spokePool,
+      deposit,
+      spokePoolClient.deploymentBlock,
+      spokePoolClient.latestBlockSearched
+    );
+  }
+
   async getBundleBlockTimestamps(
     chainIds: number[],
     blockRangesForChains: number[][],
@@ -1390,13 +1534,26 @@ 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);
-          const endBlockForChain = Math.min(_endBlockForChain, spokePoolClient.latestBlockSearched);
-          const [startTime, endTime] = [
+          // @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] = [
             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 should be greater than start time.");
+          assert(
+            endTime >= startTime,
+            `End time for block ${endBlockForChain} should be greater than start time for block ${startBlockForChain}: ${endTime} >= ${startTime}.`
+          );
           assert(
             startBlockForChain === 0 || startTime > 0,
             "Start timestamp must be greater than 0 if the start block is greater than 0."