@across-protocol/sdk 3.4.19 → 4.0.0-beta.0

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -14,6 +14,9 @@ import {
   ExpiredDepositsToRefundV3,
   Clients,
   CombinedRefunds,
+  FillWithBlock,
+  Deposit,
+  DepositWithBlock,
 } from "../../interfaces";
 import { AcrossConfigStoreClient, SpokePoolClient } from "..";
 import {
@@ -30,11 +33,9 @@ import {
   getImpliedBundleBlockRanges,
   isSlowFill,
   mapAsync,
-  filterAsync,
   bnUint32Max,
   isZeroValueDeposit,
-  chainIsEvm,
-  isValidEvmAddress,
+  findFillEvent,
 } from "../../utils";
 import winston from "winston";
 import {
@@ -49,7 +50,6 @@ import {
   prettyPrintV3SpokePoolEvents,
   V3DepositWithBlock,
   V3FillWithBlock,
-  verifyFillRepayment,
 } from "./utils";
 
 // max(uint256) - 1
@@ -59,10 +59,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], []);
@@ -83,13 +79,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: [],
@@ -99,19 +90,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;
@@ -119,10 +110,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;
     }
   }
 }
@@ -242,6 +233,7 @@ export class BundleDataClient {
       bundleData: prettyPrintV3SpokePoolEvents(
         bundleData.bundleDepositsV3,
         bundleData.bundleFillsV3,
+        [], // Invalid fills are not persisted to Arweave.
         bundleData.bundleSlowFillsV3,
         bundleData.expiredDepositsToRefundV3,
         bundleData.unexecutableSlowFills
@@ -289,7 +281,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);
@@ -310,63 +302,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);
-      const fillsToCount = await filterAsync(this.spokePoolClients[chainId].getFills(), async (fill) => {
-        if (fill.blockNumber < blockRanges[chainIndex][0] || fill.blockNumber > blockRanges[chainIndex][1]) {
-          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;
   }
@@ -410,7 +389,7 @@ export class BundleDataClient {
   async getLatestPoolRebalanceRoot(): Promise<{ root: PoolRebalanceRoot; blockRanges: number[][] }> {
     const { bundleData, blockRanges } = await this.getLatestProposedBundleData();
     const hubPoolClient = this.clients.hubPoolClient;
-    const root = _buildPoolRebalanceRoot(
+    const root = await _buildPoolRebalanceRoot(
       hubPoolClient.latestBlockSearched,
       blockRanges[0][1],
       bundleData.bundleDepositsV3,
@@ -493,7 +472,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));
@@ -508,7 +487,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.`,
@@ -675,7 +654,6 @@ 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 bundleSlowFillsV3: BundleSlowFills = {}; // Deposits that we need to send slow fills
     // for in this bundle.
     const expiredDepositsToRefundV3: ExpiredDepositsToRefundV3 = {};
@@ -691,6 +669,35 @@ export class BundleDataClient {
       return isChainDisabled(blockRangeForChain);
     };
 
+    const _canCreateSlowFillLeaf = (deposit: DepositWithBlock): boolean => {
+      return (
+        // Cannot slow fill when input and output tokens are not equivalent.
+        this.clients.hubPoolClient.areTokensEquivalent(
+          deposit.inputToken,
+          deposit.originChainId,
+          deposit.outputToken,
+          deposit.destinationChainId,
+          deposit.quoteBlockNumber
+        ) &&
+        // Cannot slow fill from or to a lite chain.
+        !deposit.fromLiteChain &&
+        !deposit.toLiteChain
+      );
+    };
+
+    const _getFillStatusForDeposit = (deposit: Deposit, queryBlock: number): Promise<FillStatus> => {
+      return spokePoolClients[deposit.destinationChainId].relayFillStatus(
+        deposit,
+        // We can assume that in production
+        // the block to query is not one that the spoke pool client
+        // hasn't queried. This is because this function will usually be called
+        // in production with block ranges that were validated by
+        // DataworkerUtils.blockRangesAreInvalidForSpokeClients.
+        Math.min(queryBlock, spokePoolClients[deposit.destinationChainId].latestBlockSearched),
+        deposit.destinationChainId
+      );
+    };
+
     // Infer chain ID's to load from number of block ranges passed in.
     const allChainIds = blockRangesForChains
       .map((_blockRange, index) => chainIds[index])
@@ -721,67 +728,13 @@ export class BundleDataClient {
       bundleBlockTimestamps = _cachedBundleTimestamps;
     }
 
-    /** *****************************
-     *
-     * Handle V3 events
-     *
-     * *****************************/
-
-    // The methodology here is roughly as follows
-    // - Query all deposits from SpokePoolClients
-    //  - If deposit is in origin chain block range, add it to bundleDepositsV3
-    //  - If deposit is expired or from an older bundle, stash it away as a deposit that may require an expired
-    //    deposit refund.
-    // - Query fills from SpokePoolClients
-    //  - If fill is in destination chain block range, then validate fill
-    //  - Fill is valid if its RelayData hash is identical to a deposit's relay data hash that we've already seen.
-    //    If we haven't seen a deposit with a matching hash, then we need to query for an older deposit earlier than
-    //    the SpokePoolClient's lookback window via queryHistoricalDepositForFill().
-    //  - If fill is valid, then add it to bundleFillsV3. If it's a slow fill execution, we won't
-    //    add a relayer refund for it, but all fills accumulate realized LP fees.
-    //    - If fill replaced a slow fill request, then stash it away as one that potentially created an
-    //      unexecutable slow fill.
-    // - Query slow fills from SpokePoolClients
-    //  - If slow fill is in destination chain block range, then validate slow fill
-    //  - Slow fill is valid if its RelayData hash is identical to a deposit's relay data hash that we've already seen,
-    //    and it does not match with a Fill that we've seen, and its input and output tokens are equivalent,
-    //    and the deposit that is being slow filled has not expired.
-    //   - Note that if we haven't can't match the slow fill with a deposit, then we need to query for an older
-    //     deposit earlier than the SpokePoolClient's lookback window via queryHistoricalDepositForFill().
-    //   - input and output tokens are considered equivalent if they map to the same L1 token via a PoolRebalanceRoute
-    //     at the deposit.quoteBlockNumber.
-    // - To validate fills that replaced slow fills, we should check that there is no slow fill request in the
-    //   current destination chain bundle block range with a matching relay hash. Additionally, the
-    //   fast fill replacing a slow fill must have filled a slow-fill eligible deposit meaning that
-    //   its input and output tokens are equivalent. We don't need to check that the slow fill was created
-    //   before the deposit expired by definition because the deposit was fast-filled, meaning that it did not
-    //   expire.
-    // - To validate deposits in the current bundle block range that expired newly in this destination
-    //   chain's current bundle block range, we only have to check that the deposit was not filled in the current
-    //   destination chain block range.
-    // - To validate deposits from a prior bundle that expired newly, we need to make sure that the deposit
-    //   was not filled. If we can't find a fill, then we should check its FillStatus on-chain via eth_call.
-    //   This will return either Unfilled, RequestedSlowFill, or Filled. If the deposit is Filled, then
-    //   then the fill happened a long time ago and we should do nothing. If the deposit is Unfilled, then
-    //   we should refund it as an expired deposit. If the deposit is RequestedSlowFill then we need to validate
-    //   that the deposit is eligible for a slow fill (its input and output tokens are equivalent) and that
-    //   the slow fill request was not sent in the current destination chain's bundle block range.
-
-    // Using the above rules, we will create a list of:
-    // - deposits in the current bundle
-    // - fast fills to refund in the current bundle
-    // - fills creating bundle LP fees in the current bundle
-    // - slow fills to create for the current bundle
-    // - deposits that expired in the current bundle
-
     // Use this dictionary to conveniently unite all events with the same relay data hash which will make
     // secondary lookups faster. The goal is to lazily fill up this dictionary with all events in the SpokePool
     // client's in-memory event cache.
     const v3RelayHashes: {
       [relayHash: string]: {
         // Note: Since there are no partial fills in v3, there should only be one fill per relay hash.
-        // There should also only be one deposit per relay hash since deposit ID's can't be re-used on the
-        // same spoke pool. Moreover, the SpokePool blocks multiple slow fill requests, so
+        // Moreover, the SpokePool blocks multiple slow fill requests, so
         // there should also only be one slow fill request per relay hash.
         deposit?: V3DepositWithBlock;
         fill?: V3FillWithBlock;
@@ -789,11 +742,10 @@ export class BundleDataClient {
       };
     } = {};
 
-    // Process all deposits first and keep track of deposits that may be refunded as an expired deposit:
-    // - expiredBundleDepositHashes: Deposits sent in this bundle that expired.
-    const expiredBundleDepositHashes: Set<string> = new Set<string>();
-    // - olderDepositHashes: Deposits sent in a prior bundle that newly expired in this bundle
-    const olderDepositHashes: Set<string> = new Set<string>();
+    // Process all deposits first and populate the v3RelayHashes dictionary. Sort deposits into whether they are
+    // in this bundle block range or in a previous bundle block range.
+    const bundleDepositHashes: string[] = [];
+    const olderDepositHashes: string[] = [];
 
     let depositCounter = 0;
     for (const originChainId of allChainIds) {
@@ -804,24 +756,22 @@ export class BundleDataClient {
         if (originChainId === destinationChainId) {
           continue;
         }
-        originClient.getDepositsForDestinationChain(destinationChainId).forEach((deposit) => {
-          if (isZeroValueDeposit(deposit)) {
+        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 (isZeroValueDeposit(deposit) || deposit.blockNumber > originChainBlockRange[1]) {
             return;
           }
           depositCounter++;
           const relayDataHash = this.getRelayHashFromEvent(deposit);
-          if (v3RelayHashes[relayDataHash]) {
-            // If we've seen this deposit before, then skip this deposit. This can happen if our RPC provider
-            // gives us bad data.
-            return;
+          if (!v3RelayHashes[relayDataHash]) {
+            v3RelayHashes[relayDataHash] = {
+              deposit: deposit,
+              fill: undefined,
+              slowFillRequest: undefined,
+            };
           }
-          // Even if deposit is not in bundle block range, store all deposits we can see in memory in this
-          // convenient dictionary.
-          v3RelayHashes[relayDataHash] = {
-            deposit: deposit,
-            fill: undefined,
-            slowFillRequest: undefined,
-          };
 
           // 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
@@ -831,24 +781,11 @@ export class BundleDataClient {
             return;
           }
 
-          // If deposit block is within origin chain bundle block range, then save as bundle deposit.
-          // If deposit is in bundle and it has expired, additionally save it as an expired deposit.
-          // Note: if the `depositor` field in the expired deposit is an invalid address, e.g. a bytes32 address on an EVM
-          // chain, then the deposit refund is invalid and ignored.
-          // If deposit is not in the bundle block range, then save it as an older deposit that
-          // may have expired.
-          if (deposit.blockNumber >= originChainBlockRange[0] && deposit.blockNumber <= originChainBlockRange[1]) {
-            // Deposit is a V3 deposit in this origin chain's bundle block range and is not a duplicate.
+          if (deposit.blockNumber >= originChainBlockRange[0]) {
+            bundleDepositHashes.push(relayDataHash);
             updateBundleDepositsV3(bundleDepositsV3, deposit);
-            // 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 impossible to create but technically should be included in this
-            // bundle of refunded deposits.
-            if (deposit.fillDeadline < bundleBlockTimestamps[destinationChainId][1]) {
-              expiredBundleDepositHashes.add(relayDataHash);
-            }
           } else if (deposit.blockNumber < originChainBlockRange[0]) {
-            olderDepositHashes.add(relayDataHash);
+            olderDepositHashes.push(relayDataHash);
           }
         });
       }
@@ -885,8 +822,9 @@ export class BundleDataClient {
             // request for the deposit, we'd want to see the fill took place.
             .filter((fill) => fill.blockNumber <= destinationChainBlockRange[1] && !isZeroValueDeposit(fill)),
           async (fill) => {
-            fillCounter++;
             const relayDataHash = this.getRelayHashFromEvent(fill);
+            fillCounter++;
+
             if (v3RelayHashes[relayDataHash]) {
               if (!v3RelayHashes[relayDataHash].fill) {
                 assert(
@@ -897,24 +835,10 @@ export class BundleDataClient {
                 // so this fill is validated.
                 v3RelayHashes[relayDataHash].fill = fill;
                 if (fill.blockNumber >= destinationChainBlockRange[0]) {
-                  const fillToRefund = await verifyFillRepayment(
-                    fill,
-                    destinationClient.spokePool.provider,
-                    v3RelayHashes[relayDataHash].deposit!,
-                    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].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.
@@ -927,17 +851,15 @@ export class BundleDataClient {
                     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. 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,
             };
 
@@ -965,31 +887,16 @@ 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)) {
-                  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;
-                }
-
                 // slow fill requests for deposits from or to lite chains are considered invalid
                 if (
                   fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill &&
@@ -1003,6 +910,8 @@ 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.
         await forEachAsync(
           destinationClient
             .getSlowFillRequestsForOriginChain(originChainId)
@@ -1017,10 +926,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. We therefore must have seen the fill
-                  // already if it exists
+                  // to create a slow fill for a filled deposit.
                   return;
                 }
                 assert(
@@ -1029,31 +935,13 @@ 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!;
-
-                // Input and Output tokens must be equivalent on the deposit for this to be slow filled.
-                if (
-                  !this.clients.hubPoolClient.areTokensEquivalent(
-                    matchedDeposit.inputToken,
-                    matchedDeposit.originChainId,
-                    matchedDeposit.outputToken,
-                    matchedDeposit.destinationChainId,
-                    matchedDeposit.quoteBlockNumber
-                  )
-                ) {
-                  return;
-                }
-
-                // slow fill requests for deposits from or to lite chains are considered invalid
-                if (
-                  v3RelayHashes[relayDataHash].deposit?.fromLiteChain ||
-                  v3RelayHashes[relayDataHash].deposit?.toLiteChain
-                ) {
+                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 and that the underlying deposit has not expired yet.
+                // destination chain block range.
                 if (
                   slowFillRequest.blockNumber >= destinationChainBlockRange[0] &&
                   // Deposit must not have expired in this bundle.
@@ -1063,8 +951,6 @@ export class BundleDataClient {
                   // so this slow fill request relay data is correct.
                   validatedBundleSlowFills.push(matchedDeposit);
                 }
-              } else {
-                throw new Error("Duplicate slow fill request detected.");
               }
               return;
             }
@@ -1106,30 +992,13 @@ export class BundleDataClient {
                 this.getRelayHashFromEvent(matchedDeposit) === relayDataHash,
                 "Deposit relay hashes should match."
               );
-
-              // slow fill requests for deposits from or to lite chains are considered invalid
-              if (matchedDeposit.fromLiteChain || matchedDeposit.toLiteChain) {
-                return;
-              }
-
               v3RelayHashes[relayDataHash].deposit = matchedDeposit;
 
-              // Note: we don't need to query for a historical fill at this point because a fill
-              // cannot precede a slow fill request and if the fill came after the slow fill request,
-              // we would have seen it already because we would have processed it in the loop above.
               if (
-                // Input and Output tokens must be equivalent on the deposit for this to be slow filled.
-                !this.clients.hubPoolClient.areTokensEquivalent(
-                  matchedDeposit.inputToken,
-                  matchedDeposit.originChainId,
-                  matchedDeposit.outputToken,
-                  matchedDeposit.destinationChainId,
-                  matchedDeposit.quoteBlockNumber
-                ) ||
+                !_canCreateSlowFillLeaf(matchedDeposit) ||
                 // Deposit must not have expired in this bundle.
                 slowFillRequest.fillDeadline < bundleBlockTimestamps[destinationChainId][1]
               ) {
-                // TODO: Invalid slow fill request. Maybe worth logging.
                 return;
               }
               validatedBundleSlowFills.push(matchedDeposit);
@@ -1137,6 +1006,113 @@ 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.
+        const originBlockRange = getBlockRangeForChain(blockRangesForChains, originChainId, chainIds);
+
+        await mapAsync(
+          bundleDepositHashes.filter((depositHash) => {
+            const { deposit } = v3RelayHashes[depositHash];
+            return (
+              deposit &&
+              deposit.originChainId === originChainId &&
+              deposit.destinationChainId === destinationChainId &&
+              deposit.blockNumber >= originBlockRange[0] &&
+              deposit.blockNumber <= originBlockRange[1] &&
+              !isZeroValueDeposit(deposit)
+            );
+          }),
+          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 (!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.
+                validatedBundleV3Fills.push({
+                  ...fill,
+                  quoteTimestamp: deposit.quoteTimestamp,
+                });
+              }
+              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 (deposit.fillDeadline < bundleBlockTimestamps[destinationChainId][1]) {
+                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
+              } else if (
+                _canCreateSlowFillLeaf(deposit) &&
+                slowFillRequest.blockNumber < destinationChainBlockRange[0]
+              ) {
+                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,
+                deposit,
+                destinationClient.deploymentBlock,
+                destinationClient.latestBlockSearched
+              )) as unknown as FillWithBlock;
+              if (!isSlowFill(prefill)) {
+                validatedBundleV3Fills.push({
+                  ...prefill,
+                  quoteTimestamp: deposit.quoteTimestamp,
+                });
+              }
+            }
+            // 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 (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 (_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);
+              }
+            }
+          }
+        );
+
         // 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.
@@ -1182,23 +1158,10 @@ export class BundleDataClient {
     });
     start = performance.now();
 
-    // Go through expired deposits in this bundle and now prune those that we have seen a fill for to construct
-    // the list of expired deposits we need to refund in this bundle.
-    expiredBundleDepositHashes.forEach((relayDataHash) => {
-      const { deposit, fill } = v3RelayHashes[relayDataHash];
-      assert(isDefined(deposit), "Deposit should exist in relay hash dictionary.");
-      if (
-        !fill &&
-        isDefined(deposit) // Needed for TSC - we check this above.
-      ) {
-        updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
-      }
-    });
-
     // 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(Array.from(olderDepositHashes), async (relayDataHash) => {
+    await forEachAsync(olderDepositHashes, async (relayDataHash) => {
       const { deposit, slowFillRequest, fill } = v3RelayHashes[relayDataHash];
       assert(isDefined(deposit), "Deposit should exist in relay hash dictionary.");
       const { destinationChainId } = deposit!;
@@ -1217,16 +1180,7 @@ export class BundleDataClient {
       ) {
         // If we haven't seen a fill matching this deposit, then we need to rule out that it was filled a long time ago
         // by checkings its on-chain fill status.
-        const fillStatus = await spokePoolClients[destinationChainId].relayFillStatus(
-          deposit,
-          // We can assume that in production
-          // the block ranges passed into this function would never contain blocks where the spoke pool client
-          // hasn't queried. This is because this function will usually be called
-          // in production with block ranges that were validated by
-          // DataworkerUtils.blockRangesAreInvalidForSpokeClients
-          Math.min(destinationBlockRange[1], spokePoolClients[destinationChainId].latestBlockSearched),
-          destinationChainId
-        );
+        const fillStatus = await _getFillStatusForDeposit(deposit, destinationBlockRange[1]);
 
         // If there is no matching fill and the deposit expired in this bundle and the fill status on-chain is not
         // Filled, then we can to refund it as an expired deposit.
@@ -1325,7 +1279,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];
@@ -1339,6 +1293,7 @@ export class BundleDataClient {
     const v3SpokeEventsReadable = prettyPrintV3SpokePoolEvents(
       bundleDepositsV3,
       bundleFillsV3,
+      bundleInvalidFillsV3,
       bundleSlowFillsV3,
       expiredDepositsToRefundV3,
       unexecutableSlowFills
@@ -1353,15 +1308,6 @@ export class BundleDataClient {
       });
     }
 
-    if (bundleUnrepayableFillsV3.length > 0) {
-      this.logger.debug({
-        at: "BundleDataClient#loadData",
-        message: "Finished loading V3 spoke pool data and found some unrepayable V3 fills in range",
-        blockRangesForChains,
-        bundleUnrepayableFillsV3,
-      });
-    }
-
     this.logger.debug({
       at: "BundleDataClient#loadDataFromScratch",
       message: `Computed bundle data in ${Math.round(performance.now() - start) / 1000}s.`,
@@ -1382,11 +1328,7 @@ export class BundleDataClient {
   // 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 {
-    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}`;
+    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(
@@ -1414,26 +1356,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."