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

package/dist/esm/clients/BundleDataClient/BundleDataClient.js

@@ -1,8 +1,8 @@
 import { __assign, __awaiter, __generator } from "tslib";
 import _ from "lodash";
 import { FillType, FillStatus, } from "../../interfaces";
-import { BigNumber, bnZero, queryHistoricalDepositForFill, assign, assert, fixedPointAdjustment, isDefined, toBN, forEachAsync, getBlockRangeForChain, getImpliedBundleBlockRanges, isSlowFill, mapAsync, bnUint32Max, isZeroValueDeposit, findFillEvent, isZeroValueFillOrSlowFillRequest, chainIsEvm, isValidEvmAddress, } from "../../utils";
-import { _buildPoolRebalanceRoot, BundleDataSS, getEndBlockBuffers, getRefundInformationFromFill, getRefundsFromBundle, getWidestPossibleExpectedBlockRange, isChainDisabled, prettyPrintV3SpokePoolEvents, } from "./utils";
+import { BigNumber, bnZero, queryHistoricalDepositForFill, assign, assert, fixedPointAdjustment, isDefined, toBN, forEachAsync, getBlockRangeForChain, getImpliedBundleBlockRanges, isSlowFill, mapAsync, filterAsync, bnUint32Max, isZeroValueDeposit, findFillEvent, isZeroValueFillOrSlowFillRequest, chainIsEvm, isValidEvmAddress, } from "../../utils";
+import { _buildPoolRebalanceRoot, BundleDataSS, getEndBlockBuffers, getRefundInformationFromFill, getRefundsFromBundle, getWidestPossibleExpectedBlockRange, isChainDisabled, isEvmRepaymentValid, prettyPrintV3SpokePoolEvents, verifyFillRepayment, } from "./utils";
 import { PRE_FILL_MIN_CONFIG_STORE_VERSION } from "../../constants";
 // max(uint256) - 1
 export var INFINITE_FILL_DEADLINE = bnUint32Max;
@@ -27,12 +27,10 @@ function updateBundleDepositsV3(dict, deposit) {
     }
     dict[originChainId][inputToken].push(deposit);
 }
-function updateBundleFillsV3(dict, fill, lpFeePct, repaymentChainId, repaymentToken) {
+function updateBundleFillsV3(dict, fill, lpFeePct, repaymentChainId, repaymentToken, repaymentAddress) {
     var _a, _b;
-    // 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 (!((_a = dict === null || dict === void 0 ? void 0 : dict[repaymentChainId]) === null || _a === void 0 ? void 0 : _a[repaymentToken])) {
         assign(dict, [repaymentChainId, repaymentToken], {
             fills: [],
@@ -41,26 +39,26 @@ function updateBundleFillsV3(dict, fill, lpFeePct, repaymentChainId, repaymentTo
             refunds: {},
         });
     }
-    var bundleFill = __assign(__assign({}, fill), { lpFeePct: lpFeePct });
+    var bundleFill = __assign(__assign({}, fill), { lpFeePct: lpFeePct, relayer: repaymentAddress });
     // Add all fills, slow and fast, to dictionary.
     assign(dict, [repaymentChainId, repaymentToken, "fills"], [bundleFill]);
     // All fills update the bundle LP fees.
     var refundObj = dict[repaymentChainId][repaymentToken];
-    var realizedLpFee = fill.inputAmount.mul(bundleFill.lpFeePct).div(fixedPointAdjustment);
+    var 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)) {
-        var refundAmount = fill.inputAmount.mul(fixedPointAdjustment.sub(lpFeePct)).div(fixedPointAdjustment);
+    if (!isSlowFill(bundleFill)) {
+        var refundAmount = bundleFill.inputAmount.mul(fixedPointAdjustment.sub(lpFeePct)).div(fixedPointAdjustment);
         refundObj.totalRefundAmount = refundObj.totalRefundAmount
             ? refundObj.totalRefundAmount.add(refundAmount)
             : refundAmount;
         // Instantiate dictionary if it doesn't exist.
         (_b = refundObj.refunds) !== null && _b !== void 0 ? _b : (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;
         }
     }
 }
@@ -74,6 +72,9 @@ function updateBundleExcessSlowFills(dict, deposit) {
 }
 function updateBundleSlowFills(dict, deposit) {
     var _a;
+    if (chainIsEvm(deposit.destinationChainId) && !isValidEvmAddress(deposit.recipient)) {
+        return;
+    }
     var destinationChainId = deposit.destinationChainId, outputToken = deposit.outputToken;
     if (!((_a = dict === null || dict === void 0 ? void 0 : dict[destinationChainId]) === null || _a === void 0 ? void 0 : _a[outputToken])) {
         assign(dict, [destinationChainId, outputToken], []);
@@ -171,8 +172,7 @@ var BundleDataClient = /** @class */ (function () {
                             at: "BundleDataClient#loadPersistedDataFromArweave",
                             message: "Loaded persisted data from Arweave in ".concat(Math.round(performance.now() - start) / 1000, "s."),
                             blockRanges: JSON.stringify(blockRangesForChains),
-                            bundleData: prettyPrintV3SpokePoolEvents(bundleData.bundleDepositsV3, bundleData.bundleFillsV3, [], // Invalid fills are not persisted to Arweave.
-                            bundleData.bundleSlowFillsV3, bundleData.expiredDepositsToRefundV3, bundleData.unexecutableSlowFills),
+                            bundleData: prettyPrintV3SpokePoolEvents(bundleData.bundleDepositsV3, bundleData.bundleFillsV3, bundleData.bundleSlowFillsV3, bundleData.expiredDepositsToRefundV3, bundleData.unexecutableSlowFills),
                         });
                         return [2 /*return*/, bundleData];
                 }
@@ -218,82 +218,124 @@ var BundleDataClient = /** @class */ (function () {
                         return [4 /*yield*/, this.loadArweaveData(bundleEvaluationBlockRanges)];
                     case 1:
                         arweaveData = _a.sent();
-                        if (arweaveData === undefined) {
-                            combinedRefunds = this.getApproximateRefundsForBlockRange(chainIds, bundleEvaluationBlockRanges);
-                        }
-                        else {
-                            bundleFillsV3 = arweaveData.bundleFillsV3, expiredDepositsToRefundV3 = arweaveData.expiredDepositsToRefundV3;
-                            combinedRefunds = getRefundsFromBundle(bundleFillsV3, expiredDepositsToRefundV3);
-                            // If we don't have a spoke pool client for a chain, then we won't be able to deduct refunds correctly for this
-                            // chain. For most of the pending bundle's liveness period, these past refunds are already executed so this is
-                            // a reasonable assumption. This empty refund chain also matches what the alternative
-                            // `getApproximateRefundsForBlockRange` would return.
-                            Object.keys(combinedRefunds).forEach(function (chainId) {
-                                if (_this.spokePoolClients[Number(chainId)] === undefined) {
-                                    delete combinedRefunds[Number(chainId)];
-                                }
-                            });
-                        }
-                        // The latest proposed bundle's refund leaves might have already been partially or entirely executed.
-                        // We have to deduct the executed amounts from the total refund amounts.
-                        return [2 /*return*/, this.deductExecutedRefunds(combinedRefunds, bundle)];
+                        if (!(arweaveData === undefined)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.getApproximateRefundsForBlockRange(chainIds, bundleEvaluationBlockRanges)];
+                    case 2:
+                        combinedRefunds = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        bundleFillsV3 = arweaveData.bundleFillsV3, expiredDepositsToRefundV3 = arweaveData.expiredDepositsToRefundV3;
+                        combinedRefunds = getRefundsFromBundle(bundleFillsV3, expiredDepositsToRefundV3);
+                        // If we don't have a spoke pool client for a chain, then we won't be able to deduct refunds correctly for this
+                        // chain. For most of the pending bundle's liveness period, these past refunds are already executed so this is
+                        // a reasonable assumption. This empty refund chain also matches what the alternative
+                        // `getApproximateRefundsForBlockRange` would return.
+                        Object.keys(combinedRefunds).forEach(function (chainId) {
+                            if (_this.spokePoolClients[Number(chainId)] === undefined) {
+                                delete combinedRefunds[Number(chainId)];
+                            }
+                        });
+                        _a.label = 4;
+                    case 4: 
+                    // The latest proposed bundle's refund leaves might have already been partially or entirely executed.
+                    // We have to deduct the executed amounts from the total refund amounts.
+                    return [2 /*return*/, this.deductExecutedRefunds(combinedRefunds, bundle)];
                 }
             });
         });
     };
     // @dev This helper function should probably be moved to the InventoryClient
     BundleDataClient.prototype.getApproximateRefundsForBlockRange = function (chainIds, blockRanges) {
-        var _this = this;
-        var refundsForChain = {};
-        var _loop_1 = function (chainId) {
-            if (this_1.spokePoolClients[chainId] === undefined) {
-                return "continue";
-            }
-            var chainIndex = chainIds.indexOf(chainId);
-            // @todo This function does not account for pre-fill refunds as it is optimized for speed. The way to detect
-            // pre-fill refunds is to load all deposits that are unmatched by fills in the spoke pool client's memory
-            // and then query the FillStatus on-chain, but that might slow this function down too much. For now, we
-            // will live with this expected inaccuracy as it should be small. The pre-fill would have to precede the deposit
-            // by more than the caller's event lookback window which is expected to be unlikely.
-            this_1.spokePoolClients[chainId]
-                .getFills()
-                .filter(function (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;
+        return __awaiter(this, void 0, void 0, function () {
+            var refundsForChain, _loop_1, this_1, _i, chainIds_1, chainId;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        refundsForChain = {};
+                        _loop_1 = function (chainId) {
+                            var chainIndex, fillsToCount;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        if (this_1.spokePoolClients[chainId] === undefined) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        chainIndex = chainIds.indexOf(chainId);
+                                        return [4 /*yield*/, filterAsync(this_1.spokePoolClients[chainId].getFills(), function (fill) { return __awaiter(_this, void 0, void 0, function () {
+                                                var matchingDeposit, hasMatchingDeposit, validRepayment;
+                                                return __generator(this, function (_a) {
+                                                    switch (_a.label) {
+                                                        case 0:
+                                                            if (fill.blockNumber < blockRanges[chainIndex][0] ||
+                                                                fill.blockNumber > blockRanges[chainIndex][1] ||
+                                                                isZeroValueFillOrSlowFillRequest(fill)) {
+                                                                return [2 /*return*/, false];
+                                                            }
+                                                            // If origin spoke pool client isn't defined, we can't validate it.
+                                                            if (this.spokePoolClients[fill.originChainId] === undefined) {
+                                                                return [2 /*return*/, false];
+                                                            }
+                                                            matchingDeposit = this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
+                                                            hasMatchingDeposit = matchingDeposit !== undefined &&
+                                                                this.getRelayHashFromEvent(fill) === this.getRelayHashFromEvent(matchingDeposit);
+                                                            if (!hasMatchingDeposit) return [3 /*break*/, 2];
+                                                            return [4 /*yield*/, 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(function (_chainId, i) { return !isChainDisabled(blockRanges[i]); }))];
+                                                        case 1:
+                                                            validRepayment = _a.sent();
+                                                            if (!isDefined(validRepayment)) {
+                                                                return [2 /*return*/, false];
+                                                            }
+                                                            _a.label = 2;
+                                                        case 2: return [2 /*return*/, hasMatchingDeposit];
+                                                    }
+                                                });
+                                            }); })];
+                                    case 1:
+                                        fillsToCount = _b.sent();
+                                        fillsToCount.forEach(function (fill) {
+                                            var _a, _b, _c;
+                                            var _d;
+                                            var matchingDeposit = _this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
+                                            assert(isDefined(matchingDeposit), "Deposit not found for fill.");
+                                            var _e = getRefundInformationFromFill(fill, _this.clients.hubPoolClient, blockRanges, _this.chainIdListForBundleEvaluationBlockNumbers, matchingDeposit.fromLiteChain // Use ! because we've already asserted that matchingDeposit is defined.
+                                            ), chainToSendRefundTo = _e.chainToSendRefundTo, repaymentToken = _e.repaymentToken;
+                                            // 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.
+                                            var relayer = fill.relayer, refundAmount = fill.inputAmount;
+                                            (_a = refundsForChain[chainToSendRefundTo]) !== null && _a !== void 0 ? _a : (refundsForChain[chainToSendRefundTo] = {});
+                                            (_b = (_d = refundsForChain[chainToSendRefundTo])[repaymentToken]) !== null && _b !== void 0 ? _b : (_d[repaymentToken] = {});
+                                            var existingRefundAmount = (_c = refundsForChain[chainToSendRefundTo][repaymentToken][relayer]) !== null && _c !== void 0 ? _c : bnZero;
+                                            refundsForChain[chainToSendRefundTo][repaymentToken][relayer] = existingRefundAmount.add(refundAmount);
+                                        });
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _i = 0, chainIds_1 = chainIds;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < chainIds_1.length)) return [3 /*break*/, 4];
+                        chainId = chainIds_1[_i];
+                        return [5 /*yield**/, _loop_1(chainId)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, refundsForChain];
                 }
-                var matchingDeposit = _this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
-                var hasMatchingDeposit = matchingDeposit !== undefined &&
-                    _this.getRelayHashFromEvent(fill) === _this.getRelayHashFromEvent(matchingDeposit);
-                return hasMatchingDeposit;
-            })
-                .forEach(function (fill) {
-                var _a, _b, _c;
-                var _d;
-                var matchingDeposit = _this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
-                assert(isDefined(matchingDeposit), "Deposit not found for fill.");
-                var _e = getRefundInformationFromFill(fill, _this.clients.hubPoolClient, blockRanges, _this.chainIdListForBundleEvaluationBlockNumbers, matchingDeposit.fromLiteChain // Use ! because we've already asserted that matchingDeposit is defined.
-                ), chainToSendRefundTo = _e.chainToSendRefundTo, repaymentToken = _e.repaymentToken;
-                // 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.
-                var relayer = fill.relayer, refundAmount = fill.inputAmount;
-                (_a = refundsForChain[chainToSendRefundTo]) !== null && _a !== void 0 ? _a : (refundsForChain[chainToSendRefundTo] = {});
-                (_b = (_d = refundsForChain[chainToSendRefundTo])[repaymentToken]) !== null && _b !== void 0 ? _b : (_d[repaymentToken] = {});
-                var existingRefundAmount = (_c = refundsForChain[chainToSendRefundTo][repaymentToken][relayer]) !== null && _c !== void 0 ? _c : bnZero;
-                refundsForChain[chainToSendRefundTo][repaymentToken][relayer] = existingRefundAmount.add(refundAmount);
             });
-        };
-        var this_1 = this;
-        for (var _i = 0, chainIds_1 = chainIds; _i < chainIds_1.length; _i++) {
-            var chainId = chainIds_1[_i];
-            _loop_1(chainId);
-        }
-        return refundsForChain;
+        });
     };
     BundleDataClient.prototype.getUpcomingDepositAmount = function (chainId, l2Token, latestBlockToSearch) {
         if (this.spokePoolClients[chainId] === undefined) {
@@ -338,12 +380,10 @@ var BundleDataClient = /** @class */ (function () {
                     case 1:
                         _a = _b.sent(), bundleData = _a.bundleData, blockRanges = _a.blockRanges;
                         hubPoolClient = this.clients.hubPoolClient;
-                        return [4 /*yield*/, _buildPoolRebalanceRoot(hubPoolClient.latestBlockSearched, blockRanges[0][1], bundleData.bundleDepositsV3, bundleData.bundleFillsV3, bundleData.bundleSlowFillsV3, bundleData.unexecutableSlowFills, bundleData.expiredDepositsToRefundV3, {
-                                hubPoolClient: hubPoolClient,
-                                configStoreClient: hubPoolClient.configStoreClient,
-                            })];
-                    case 2:
-                        root = _b.sent();
+                        root = _buildPoolRebalanceRoot(hubPoolClient.latestBlockSearched, blockRanges[0][1], bundleData.bundleDepositsV3, bundleData.bundleFillsV3, bundleData.bundleSlowFillsV3, bundleData.unexecutableSlowFills, bundleData.expiredDepositsToRefundV3, {
+                            hubPoolClient: hubPoolClient,
+                            configStoreClient: hubPoolClient.configStoreClient,
+                        });
                         return [2 /*return*/, {
                                 root: root,
                                 blockRanges: blockRanges,
@@ -385,33 +425,40 @@ var BundleDataClient = /** @class */ (function () {
                     return [initialBlockRange[1] + 1, blockRange[1]];
                 });
             }
-            var hubPoolClient, nextBundleMainnetStartBlock, chainIds, combinedRefunds, widestBundleBlockRanges, pendingBundleBlockRanges, arweaveData, bundleFillsV3, expiredDepositsToRefundV3, start;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var hubPoolClient, nextBundleMainnetStartBlock, chainIds, combinedRefunds, widestBundleBlockRanges, pendingBundleBlockRanges, arweaveData, _a, _b, bundleFillsV3, expiredDepositsToRefundV3, start, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         hubPoolClient = this.clients.hubPoolClient;
                         nextBundleMainnetStartBlock = hubPoolClient.getNextBundleStartBlockNumber(this.chainIdListForBundleEvaluationBlockNumbers, hubPoolClient.latestBlockSearched, hubPoolClient.chainId);
                         chainIds = this.clients.configStoreClient.getChainIdIndicesForBlock(nextBundleMainnetStartBlock);
                         combinedRefunds = [];
                         widestBundleBlockRanges = getWidestPossibleExpectedBlockRange(chainIds, this.spokePoolClients, getEndBlockBuffers(chainIds, this.blockRangeEndBlockBuffer), this.clients, this.clients.hubPoolClient.latestBlockSearched, this.clients.configStoreClient.getEnabledChains(this.clients.hubPoolClient.latestBlockSearched));
-                        if (!hubPoolClient.hasPendingProposal()) return [3 /*break*/, 2];
+                        if (!hubPoolClient.hasPendingProposal()) return [3 /*break*/, 5];
                         pendingBundleBlockRanges = getImpliedBundleBlockRanges(hubPoolClient, this.clients.configStoreClient, hubPoolClient.getLatestProposedRootBundle());
                         return [4 /*yield*/, this.loadArweaveData(pendingBundleBlockRanges)];
                     case 1:
-                        arweaveData = _a.sent();
-                        if (arweaveData === undefined) {
-                            combinedRefunds.push(this.getApproximateRefundsForBlockRange(chainIds, pendingBundleBlockRanges));
-                        }
-                        else {
-                            bundleFillsV3 = arweaveData.bundleFillsV3, expiredDepositsToRefundV3 = arweaveData.expiredDepositsToRefundV3;
-                            combinedRefunds.push(getRefundsFromBundle(bundleFillsV3, expiredDepositsToRefundV3));
-                        }
+                        arweaveData = _e.sent();
+                        if (!(arweaveData === undefined)) return [3 /*break*/, 3];
+                        _b = (_a = combinedRefunds).push;
+                        return [4 /*yield*/, this.getApproximateRefundsForBlockRange(chainIds, pendingBundleBlockRanges)];
+                    case 2:
+                        _b.apply(_a, [_e.sent()]);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        bundleFillsV3 = arweaveData.bundleFillsV3, expiredDepositsToRefundV3 = arweaveData.expiredDepositsToRefundV3;
+                        combinedRefunds.push(getRefundsFromBundle(bundleFillsV3, expiredDepositsToRefundV3));
+                        _e.label = 4;
+                    case 4:
                         // Shorten the widestBundleBlockRanges now to not double count the pending bundle blocks.
                         widestBundleBlockRanges = getBlockRangeDelta(pendingBundleBlockRanges);
-                        _a.label = 2;
-                    case 2:
+                        _e.label = 5;
+                    case 5:
                         start = performance.now();
-                        combinedRefunds.push(this.getApproximateRefundsForBlockRange(chainIds, widestBundleBlockRanges));
+                        _d = (_c = combinedRefunds).push;
+                        return [4 /*yield*/, this.getApproximateRefundsForBlockRange(chainIds, widestBundleBlockRanges)];
+                    case 6:
+                        _d.apply(_c, [_e.sent()]);
                         this.logger.debug({
                             at: "BundleDataClient#getNextBundleRefunds",
                             message: "Loading approximate refunds for next bundle in ".concat(Math.round(performance.now() - start) / 1000, "s."),
@@ -554,7 +601,7 @@ var BundleDataClient = /** @class */ (function () {
     };
     BundleDataClient.prototype.loadDataFromScratch = function (blockRangesForChains, spokePoolClients) {
         return __awaiter(this, void 0, void 0, function () {
-            var start, key, chainIds, bundleDepositsV3, bundleFillsV3, bundleInvalidFillsV3, bundleSlowFillsV3, expiredDepositsToRefundV3, unexecutableSlowFills, _isChainDisabled, _canCreateSlowFillLeaf, _depositIsExpired, _getFillStatusForDeposit, allChainIds, _cachedBundleTimestamps, bundleBlockTimestamps, v3RelayHashes, bundleDepositHashes, olderDepositHashes, startBlockForMainnet, versionAtProposalBlock, canRefundPrefills, depositCounter, _loop_2, _i, allChainIds_1, originChainId, validatedBundleV3Fills, validatedBundleSlowFills, validatedBundleUnexecutableSlowFills, fillCounter, _loop_3, _a, allChainIds_2, originChainId, promises, _b, v3FillLpFees, v3SlowFillLpFees, v3UnexecutableSlowFillLpFees, v3SpokeEventsReadable;
+            var start, key, chainIds, bundleDepositsV3, bundleFillsV3, bundleInvalidFillsV3, bundleUnrepayableFillsV3, bundleInvalidSlowFillRequests, bundleSlowFillsV3, expiredDepositsToRefundV3, unexecutableSlowFills, _isChainDisabled, _canCreateSlowFillLeaf, _depositIsExpired, _getFillStatusForDeposit, allChainIds, _cachedBundleTimestamps, bundleBlockTimestamps, v3RelayHashes, bundleDepositHashes, olderDepositHashes, decodeBundleDepositHash, startBlockForMainnet, versionAtProposalBlock, canRefundPrefills, _loop_2, _i, allChainIds_1, originChainId, validatedBundleV3Fills, validatedBundleSlowFills, validatedBundleUnexecutableSlowFills, fillCounter, _loop_3, _a, allChainIds_2, originChainId, promises, _b, v3FillLpFees, v3SlowFillLpFees, v3UnexecutableSlowFillLpFees, v3SpokeEventsReadable;
             var _this = this;
             return __generator(this, function (_c) {
                 switch (_c.label) {
@@ -574,6 +621,8 @@ var BundleDataClient = /** @class */ (function () {
                         bundleDepositsV3 = {};
                         bundleFillsV3 = {};
                         bundleInvalidFillsV3 = [];
+                        bundleUnrepayableFillsV3 = [];
+                        bundleInvalidSlowFillRequests = [];
                         bundleSlowFillsV3 = {};
                         expiredDepositsToRefundV3 = {};
                         unexecutableSlowFills = {};
@@ -631,10 +680,13 @@ var BundleDataClient = /** @class */ (function () {
                         v3RelayHashes = {};
                         bundleDepositHashes = [];
                         olderDepositHashes = [];
+                        decodeBundleDepositHash = function (depositHash) {
+                            var _a = depositHash.split("@"), relayDataHash = _a[0], i = _a[1];
+                            return { relayDataHash: relayDataHash, index: Number(i) };
+                        };
                         startBlockForMainnet = getBlockRangeForChain(blockRangesForChains, this.clients.hubPoolClient.chainId, this.chainIdListForBundleEvaluationBlockNumbers)[0];
                         versionAtProposalBlock = this.clients.configStoreClient.getConfigStoreVersionForBlock(startBlockForMainnet);
                         canRefundPrefills = versionAtProposalBlock >= PRE_FILL_MIN_CONFIG_STORE_VERSION || process.env.FORCE_REFUND_PREFILLS === "true";
-                        depositCounter = 0;
                         _loop_2 = function (originChainId) {
                             var originClient = spokePoolClients[originChainId];
                             var originChainBlockRange = getBlockRangeForChain(blockRangesForChains, originChainId, chainIds);
@@ -644,48 +696,45 @@ var BundleDataClient = /** @class */ (function () {
                                     continue;
                                 }
                                 originClient.getDepositsForDestinationChainWithDuplicates(destinationChainId).forEach(function (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++;
                                     var relayDataHash = _this.getRelayHashFromEvent(deposit);
-                                    // Duplicate deposits are treated like normal deposits.
                                     if (!v3RelayHashes[relayDataHash]) {
                                         v3RelayHashes[relayDataHash] = {
-                                            deposit: deposit,
+                                            deposits: [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
-                                    // 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;
+                                    else {
+                                        v3RelayHashes[relayDataHash].deposits.push(deposit);
                                     }
-                                    // 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.
+                                    var newBundleDepositHash = "".concat(relayDataHash, "@").concat(v3RelayHashes[relayDataHash].deposits.length - 1);
+                                    var 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);
                                     }
                                 });
                             }
                         };
+                        // Prerequisite step: Load all deposit events from the current or older bundles into the v3RelayHashes dictionary
+                        // for convenient matching with fills.
                         for (_i = 0, allChainIds_1 = allChainIds; _i < allChainIds_1.length; _i++) {
                             originChainId = allChainIds_1[_i];
                             _loop_2(originChainId);
                         }
                         this.logger.debug({
                             at: "BundleDataClient#loadData",
-                            message: "Processed ".concat(depositCounter, " deposits in ").concat(performance.now() - start, "ms."),
+                            message: "Processed ".concat(bundleDepositHashes.length + olderDepositHashes.length, " deposits in ").concat(performance.now() - start, "ms."),
                         });
                         start = performance.now();
                         validatedBundleV3Fills = [];
@@ -699,7 +748,7 @@ var BundleDataClient = /** @class */ (function () {
                                     case 0:
                                         originClient = spokePoolClients[originChainId];
                                         _loop_4 = function (destinationChainId) {
-                                            var destinationClient, destinationChainBlockRange, fastFillsReplacingSlowFills;
+                                            var destinationClient, destinationChainBlockRange, originChainBlockRange, fastFillsReplacingSlowFills;
                                             return __generator(this, function (_g) {
                                                 switch (_g.label) {
                                                     case 0:
@@ -708,6 +757,7 @@ var BundleDataClient = /** @class */ (function () {
                                                         }
                                                         destinationClient = spokePoolClients[destinationChainId];
                                                         destinationChainBlockRange = getBlockRangeForChain(blockRangesForChains, destinationChainId, chainIds);
+                                                        originChainBlockRange = getBlockRangeForChain(blockRangesForChains, originChainId, chainIds);
                                                         fastFillsReplacingSlowFills = [];
                                                         return [4 /*yield*/, forEachAsync(destinationClient
                                                                 .getFillsForOriginChain(originChainId)
@@ -715,40 +765,58 @@ var BundleDataClient = /** @class */ (function () {
                                                                 // tokens to the filler. We can't remove non-empty message deposit here in case there is a slow fill
                                                                 // request for the deposit, we'd want to see the fill took place.
                                                                 .filter(function (fill) { return fill.blockNumber <= destinationChainBlockRange[1] && !isZeroValueFillOrSlowFillRequest(fill); }), function (fill) { return __awaiter(_this, void 0, void 0, function () {
-                                                                var relayDataHash, fillTransaction, originRelayer, historicalDeposit, matchedDeposit;
+                                                                var relayDataHash, fillToRefund_1, duplicateDeposits, historicalDeposit, matchedDeposit, fillToRefund;
                                                                 return __generator(this, function (_a) {
                                                                     switch (_a.label) {
                                                                         case 0:
-                                                                            relayDataHash = this.getRelayHashFromEvent(fill);
                                                                             fillCounter++;
-                                                                            if (v3RelayHashes[relayDataHash]) {
-                                                                                if (!v3RelayHashes[relayDataHash].fill) {
-                                                                                    assert(isDefined(v3RelayHashes[relayDataHash].deposit), "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(__assign(__assign({}, fill), { quoteTimestamp: v3RelayHashes[relayDataHash].deposit.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)) {
-                                                                                            fastFillsReplacingSlowFills.push(relayDataHash);
-                                                                                        }
+                                                                            relayDataHash = this.getRelayHashFromEvent(fill);
+                                                                            if (!v3RelayHashes[relayDataHash]) return [3 /*break*/, 5];
+                                                                            if (!!v3RelayHashes[relayDataHash].fill) return [3 /*break*/, 3];
+                                                                            assert(isDefined(v3RelayHashes[relayDataHash].deposits) && v3RelayHashes[relayDataHash].deposits.length > 0, "Deposit should exist in relay hash dictionary.");
+                                                                            v3RelayHashes[relayDataHash].fill = fill;
+                                                                            if (!(fill.blockNumber >= destinationChainBlockRange[0])) return [3 /*break*/, 2];
+                                                                            return [4 /*yield*/, verifyFillRepayment(fill, destinationClient.spokePool.provider, v3RelayHashes[relayDataHash].deposits[0], allChainIds)];
+                                                                        case 1:
+                                                                            fillToRefund_1 = _a.sent();
+                                                                            if (!isDefined(fillToRefund_1)) {
+                                                                                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_1;
+                                                                                validatedBundleV3Fills.push(__assign(__assign({}, fillToRefund_1), { quoteTimestamp: v3RelayHashes[relayDataHash].deposits[0].quoteTimestamp }));
+                                                                                duplicateDeposits = v3RelayHashes[relayDataHash].deposits.slice(1);
+                                                                                duplicateDeposits.forEach(function (duplicateDeposit) {
+                                                                                    if (isSlowFill(fill)) {
+                                                                                        updateExpiredDepositsV3(expiredDepositsToRefundV3, duplicateDeposit);
                                                                                     }
-                                                                                }
-                                                                                return [2 /*return*/];
+                                                                                    else {
+                                                                                        validatedBundleV3Fills.push(__assign(__assign({}, fillToRefund_1), { 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.
+                                                                            if (fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill &&
+                                                                                _canCreateSlowFillLeaf(v3RelayHashes[relayDataHash].deposits[0])) {
+                                                                                fastFillsReplacingSlowFills.push(relayDataHash);
+                                                                            }
+                                                                            _a.label = 2;
+                                                                        case 2: return [3 /*break*/, 4];
+                                                                        case 3: throw new Error("Duplicate fill detected");
+                                                                        case 4: return [2 /*return*/];
+                                                                        case 5:
                                                                             // 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,
+                                                                                deposits: undefined,
                                                                                 fill: fill,
                                                                                 slowFillRequest: undefined,
                                                                             };
-                                                                            if (!(fill.blockNumber >= destinationChainBlockRange[0])) return [3 /*break*/, 4];
+                                                                            if (!(fill.blockNumber >= destinationChainBlockRange[0])) return [3 /*break*/, 9];
                                                                             // Fill has a non-infinite expiry, and we can assume our spoke pool clients have old enough deposits
                                                                             // to conclude that this fill is invalid if we haven't found a matching deposit in memory, so
                                                                             // skip the historical query.
@@ -756,49 +824,58 @@ var BundleDataClient = /** @class */ (function () {
                                                                                 bundleInvalidFillsV3.push(fill);
                                                                                 return [2 /*return*/];
                                                                             }
-                                                                            if (!(chainIsEvm(fill.repaymentChainId) && !isValidEvmAddress(fill.relayer))) return [3 /*break*/, 2];
-                                                                            return [4 /*yield*/, originClient.spokePool.provider.getTransaction(fill.transactionHash)];
-                                                                        case 1:
-                                                                            fillTransaction = _a.sent();
-                                                                            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)) {
+                                                                            return [4 /*yield*/, queryHistoricalDepositForFill(originClient, fill)];
+                                                                        case 6:
+                                                                            historicalDeposit = _a.sent();
+                                                                            if (!!historicalDeposit.found) return [3 /*break*/, 7];
+                                                                            bundleInvalidFillsV3.push(fill);
+                                                                            return [3 /*break*/, 9];
+                                                                        case 7:
+                                                                            matchedDeposit = historicalDeposit.deposit;
+                                                                            // 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 [2 /*return*/];
                                                                             }
-                                                                            // Otherwise, assume the relayer to be repaid is the msg.sender.
-                                                                            fill.relayer = originRelayer;
-                                                                            _a.label = 2;
-                                                                        case 2: return [4 /*yield*/, queryHistoricalDepositForFill(originClient, fill)];
-                                                                        case 3:
-                                                                            historicalDeposit = _a.sent();
-                                                                            if (!historicalDeposit.found) {
-                                                                                bundleInvalidFillsV3.push(fill);
+                                                                            v3RelayHashes[relayDataHash].deposits = [matchedDeposit];
+                                                                            return [4 /*yield*/, verifyFillRepayment(fill, destinationClient.spokePool.provider, matchedDeposit, allChainIds)];
+                                                                        case 8:
+                                                                            fillToRefund = _a.sent();
+                                                                            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 {
-                                                                                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(__assign(__assign({}, fill), { quoteTimestamp: matchedDeposit.quoteTimestamp }));
-                                                                                v3RelayHashes[relayDataHash].deposit = matchedDeposit;
-                                                                                // slow fill requests for deposits from or to lite chains are considered invalid
-                                                                                if (fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill &&
-                                                                                    _canCreateSlowFillLeaf(matchedDeposit)) {
-                                                                                    fastFillsReplacingSlowFills.push(relayDataHash);
-                                                                                }
+                                                                                validatedBundleV3Fills.push(__assign(__assign({}, 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().
                                                                             }
-                                                                            _a.label = 4;
-                                                                        case 4: return [2 /*return*/];
+                                                                            if (fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill &&
+                                                                                _canCreateSlowFillLeaf(matchedDeposit)) {
+                                                                                fastFillsReplacingSlowFills.push(relayDataHash);
+                                                                            }
+                                                                            _a.label = 9;
+                                                                        case 9: return [2 /*return*/];
                                                                     }
                                                                 });
                                                             }); })];
                                                     case 1:
                                                         _g.sent();
-                                                        // 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.
                                                         return [4 /*yield*/, forEachAsync(destinationClient
                                                                 .getSlowFillRequestsForOriginChain(originChainId)
                                                                 .filter(function (request) {
@@ -811,55 +888,58 @@ var BundleDataClient = /** @class */ (function () {
                                                                             relayDataHash = this.getRelayHashFromEvent(slowFillRequest);
                                                                             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 [2 /*return*/];
                                                                                     }
-                                                                                    assert(isDefined(v3RelayHashes[relayDataHash].deposit), "Deposit should exist in relay hash dictionary.");
-                                                                                    matchedDeposit = v3RelayHashes[relayDataHash].deposit;
-                                                                                    // 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.
+                                                                                    assert(isDefined(v3RelayHashes[relayDataHash].deposits) && v3RelayHashes[relayDataHash].deposits.length > 0, "Deposit should exist in relay hash dictionary.");
+                                                                                    matchedDeposit = v3RelayHashes[relayDataHash].deposits[0];
                                                                                     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 [2 /*return*/];
                                                                             }
                                                                             // Instantiate dictionary if there is neither a deposit nor fill matching it.
                                                                             v3RelayHashes[relayDataHash] = {
-                                                                                deposit: undefined,
+                                                                                deposits: undefined,
                                                                                 fill: undefined,
                                                                                 slowFillRequest: slowFillRequest,
                                                                             };
-                                                                            if (!(slowFillRequest.blockNumber >= destinationChainBlockRange[0] &&
-                                                                                INFINITE_FILL_DEADLINE.eq(slowFillRequest.fillDeadline))) return [3 /*break*/, 2];
+                                                                            if (!(slowFillRequest.blockNumber >= destinationChainBlockRange[0])) return [3 /*break*/, 2];
+                                                                            if (!INFINITE_FILL_DEADLINE.eq(slowFillRequest.fillDeadline)) {
+                                                                                bundleInvalidSlowFillRequests.push(slowFillRequest);
+                                                                                return [2 /*return*/];
+                                                                            }
                                                                             return [4 /*yield*/, queryHistoricalDepositForFill(originClient, slowFillRequest)];
                                                                         case 1:
                                                                             historicalDeposit = _a.sent();
                                                                             if (!historicalDeposit.found) {
-                                                                                // TODO: Invalid slow fill request. Maybe worth logging.
+                                                                                bundleInvalidSlowFillRequests.push(slowFillRequest);
                                                                                 return [2 /*return*/];
                                                                             }
                                                                             matchedDeposit = 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 [2 /*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
                                                                             // historical deposit query is not working as expected.
                                                                             assert(this.getRelayHashFromEvent(matchedDeposit) === relayDataHash, "Deposit relay hashes should match.");
-                                                                            v3RelayHashes[relayDataHash].deposit = matchedDeposit;
-                                                                            if (!_canCreateSlowFillLeaf(matchedDeposit) ||
-                                                                                // Deposit must not have expired in this bundle.
-                                                                                _depositIsExpired(matchedDeposit)) {
+                                                                            v3RelayHashes[relayDataHash].deposits = [matchedDeposit];
+                                                                            if (!_canCreateSlowFillLeaf(matchedDeposit) || _depositIsExpired(matchedDeposit)) {
                                                                                 return [2 /*return*/];
                                                                             }
                                                                             validatedBundleSlowFills.push(matchedDeposit);
@@ -869,121 +949,167 @@ var BundleDataClient = /** @class */ (function () {
                                                                 });
                                                             }); })];
                                                     case 2:
-                                                        // 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.
                                                         _g.sent();
-                                                        // 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.
-                                                        return [4 /*yield*/, mapAsync(bundleDepositHashes.filter(function (depositHash) {
-                                                                var deposit = v3RelayHashes[depositHash].deposit;
-                                                                return (deposit && deposit.originChainId === originChainId && deposit.destinationChainId === destinationChainId);
-                                                            }), function (depositHash) { return __awaiter(_this, void 0, void 0, function () {
-                                                                var _a, deposit, fill, slowFillRequest, fillStatus, prefill;
-                                                                return __generator(this, function (_b) {
-                                                                    switch (_b.label) {
+                                                        // 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.
+                                                        return [4 /*yield*/, mapAsync(bundleDepositHashes, function (depositHash) { return __awaiter(_this, void 0, void 0, function () {
+                                                                var _a, relayDataHash, index, _b, deposits, fill, slowFillRequest, deposit, fillToRefund, fillStatus, prefill, verifiedFill;
+                                                                var _this = this;
+                                                                return __generator(this, function (_c) {
+                                                                    switch (_c.label) {
                                                                         case 0:
-                                                                            _a = v3RelayHashes[depositHash], deposit = _a.deposit, fill = _a.fill, slowFillRequest = _a.slowFillRequest;
+                                                                            _a = decodeBundleDepositHash(depositHash), relayDataHash = _a.relayDataHash, index = _a.index;
+                                                                            _b = v3RelayHashes[relayDataHash], deposits = _b.deposits, fill = _b.fill, slowFillRequest = _b.slowFillRequest;
+                                                                            if (!deposits || deposits.length === 0) {
+                                                                                throw new Error("Deposits should exist in relay hash dictionary.");
+                                                                            }
+                                                                            deposit = deposits[index];
                                                                             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.
-                                                                                    validatedBundleV3Fills.push(__assign(__assign({}, fill), { quoteTimestamp: deposit.quoteTimestamp }));
-                                                                                }
+                                                                            if (deposit.originChainId !== originChainId || deposit.destinationChainId !== destinationChainId) {
                                                                                 return [2 /*return*/];
                                                                             }
+                                                                            if (!fill) return [3 /*break*/, 3];
+                                                                            if (!(canRefundPrefills && fill.blockNumber < destinationChainBlockRange[0])) return [3 /*break*/, 2];
+                                                                            return [4 /*yield*/, verifyFillRepayment(fill, destinationClient.spokePool.provider, v3RelayHashes[relayDataHash].deposits[0], allChainIds)];
+                                                                        case 1:
+                                                                            fillToRefund = _c.sent();
+                                                                            if (!isDefined(fillToRefund)) {
+                                                                                bundleUnrepayableFillsV3.push(fill);
+                                                                            }
+                                                                            else if (!isSlowFill(fill)) {
+                                                                                v3RelayHashes[relayDataHash].fill = fillToRefund;
+                                                                                validatedBundleV3Fills.push(__assign(__assign({}, fillToRefund), { quoteTimestamp: deposit.quoteTimestamp }));
+                                                                            }
+                                                                            else {
+                                                                                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
+                                                                            }
+                                                                            _c.label = 2;
+                                                                        case 2: return [2 /*return*/];
+                                                                        case 3:
                                                                             // 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.
+                                                                            // 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)) {
+                                                                                    _canCreateSlowFillLeaf(deposit) &&
+                                                                                    validatedBundleSlowFills.every(function (d) { return _this.getRelayHashFromEvent(d) !== relayDataHash; })) {
                                                                                     validatedBundleSlowFills.push(deposit);
                                                                                 }
                                                                                 return [2 /*return*/];
                                                                             }
                                                                             return [4 /*yield*/, _getFillStatusForDeposit(deposit, destinationChainBlockRange[1])];
-                                                                        case 1:
-                                                                            fillStatus = _b.sent();
-                                                                            if (!(fillStatus === FillStatus.Filled)) return [3 /*break*/, 3];
-                                                                            return [4 /*yield*/, findFillEvent(destinationClient.spokePool, deposit, destinationClient.deploymentBlock, destinationClient.latestBlockSearched)];
-                                                                        case 2:
-                                                                            prefill = (_b.sent());
-                                                                            if (canRefundPrefills && !isSlowFill(prefill)) {
-                                                                                validatedBundleV3Fills.push(__assign(__assign({}, prefill), { quoteTimestamp: deposit.quoteTimestamp }));
+                                                                        case 4:
+                                                                            fillStatus = _c.sent();
+                                                                            if (!(fillStatus === FillStatus.Filled)) return [3 /*break*/, 8];
+                                                                            return [4 /*yield*/, this.findMatchingFillEvent(deposit, destinationClient)];
+                                                                        case 5:
+                                                                            prefill = _c.sent();
+                                                                            assert(isDefined(prefill), "findFillEvent# Cannot find prefill: ".concat(relayDataHash));
+                                                                            assert(this.getRelayHashFromEvent(prefill) === relayDataHash, "Relay hashes should match.");
+                                                                            if (!canRefundPrefills) return [3 /*break*/, 7];
+                                                                            return [4 /*yield*/, verifyFillRepayment(prefill, destinationClient.spokePool.provider, deposit, allChainIds)];
+                                                                        case 6:
+                                                                            verifiedFill = _c.sent();
+                                                                            if (!isDefined(verifiedFill)) {
+                                                                                bundleUnrepayableFillsV3.push(prefill);
                                                                             }
-                                                                            return [3 /*break*/, 4];
-                                                                        case 3:
+                                                                            else if (!isSlowFill(verifiedFill)) {
+                                                                                validatedBundleV3Fills.push(__assign(__assign({}, verifiedFill), { quoteTimestamp: deposit.quoteTimestamp }));
+                                                                            }
+                                                                            else {
+                                                                                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
+                                                                            }
+                                                                            _c.label = 7;
+                                                                        case 7: return [3 /*break*/, 9];
+                                                                        case 8:
                                                                             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
+                                                                            else if (fillStatus === FillStatus.RequestedSlowFill &&
+                                                                                // Don't create duplicate slow fill requests for the same deposit.
+                                                                                validatedBundleSlowFills.every(function (d) { return _this.getRelayHashFromEvent(d) !== relayDataHash; })) {
                                                                                 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);
                                                                                 }
                                                                             }
-                                                                            _b.label = 4;
-                                                                        case 4: return [2 /*return*/];
+                                                                            _c.label = 9;
+                                                                        case 9: return [2 /*return*/];
                                                                     }
                                                                 });
                                                             }); })];
                                                     case 3:
-                                                        // 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.
+                                                        // 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.
                                                         _g.sent();
                                                         // 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(function (relayDataHash) {
-                                                            var _a = v3RelayHashes[relayDataHash], deposit = _a.deposit, slowFillRequest = _a.slowFillRequest, fill = _a.fill;
+                                                            var _a = v3RelayHashes[relayDataHash], deposits = _a.deposits, slowFillRequest = _a.slowFillRequest, fill = _a.fill;
                                                             assert((fill === null || fill === void 0 ? void 0 : 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), "fastFillsReplacingSlowFills should contain only deposits that can be slow filled");
+                                                            assert(_canCreateSlowFillLeaf(deposits[0]), "fastFillsReplacingSlowFills should contain only deposits that can be slow filled");
                                                             var destinationBlockRange = getBlockRangeForChain(blockRangesForChains, destinationChainId, chainIds);
                                                             if (
                                                             // If there is a slow fill request in this bundle that matches the relay hash, then there was no slow fill
                                                             // created that would be considered excess.
                                                             !slowFillRequest ||
                                                                 slowFillRequest.blockNumber < destinationBlockRange[0]) {
-                                                                validatedBundleUnexecutableSlowFills.push(deposit);
+                                                                validatedBundleUnexecutableSlowFills.push(deposits[0]);
                                                             }
                                                         });
                                                         return [2 /*return*/];
@@ -1027,13 +1153,17 @@ var BundleDataClient = /** @class */ (function () {
                         // 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.
-                        return [4 /*yield*/, forEachAsync(olderDepositHashes, function (relayDataHash) { return __awaiter(_this, void 0, void 0, function () {
-                                var _a, deposit, slowFillRequest, fill, destinationChainId, destinationBlockRange, fillStatus;
-                                return __generator(this, function (_b) {
-                                    switch (_b.label) {
+                        return [4 /*yield*/, forEachAsync(olderDepositHashes, function (depositHash) { return __awaiter(_this, void 0, void 0, function () {
+                                var _a, relayDataHash, index, _b, deposits, slowFillRequest, fill, deposit, destinationChainId, destinationBlockRange, fillStatus;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
                                         case 0:
-                                            _a = v3RelayHashes[relayDataHash], deposit = _a.deposit, slowFillRequest = _a.slowFillRequest, fill = _a.fill;
-                                            assert(isDefined(deposit), "Deposit should exist in relay hash dictionary.");
+                                            _a = decodeBundleDepositHash(depositHash), relayDataHash = _a.relayDataHash, index = _a.index;
+                                            _b = v3RelayHashes[relayDataHash], deposits = _b.deposits, slowFillRequest = _b.slowFillRequest, fill = _b.fill;
+                                            if (!deposits || deposits.length < 1) {
+                                                throw new Error("Deposit should exist in relay hash dictionary.");
+                                            }
+                                            deposit = deposits[index];
                                             destinationChainId = deposit.destinationChainId;
                                             destinationBlockRange = getBlockRangeForChain(blockRangesForChains, destinationChainId, chainIds);
                                             if (!
@@ -1047,7 +1177,7 @@ var BundleDataClient = /** @class */ (function () {
                                             return [3 /*break*/, 2];
                                             return [4 /*yield*/, _getFillStatusForDeposit(deposit, destinationBlockRange[1])];
                                         case 1:
-                                            fillStatus = _b.sent();
+                                            fillStatus = _c.sent();
                                             // 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.
                                             if (fillStatus !== FillStatus.Filled) {
@@ -1069,7 +1199,7 @@ var BundleDataClient = /** @class */ (function () {
                                             if (!slowFillRequest || slowFillRequest.blockNumber < destinationBlockRange[0]) {
                                                 validatedBundleUnexecutableSlowFills.push(deposit);
                                             }
-                                            _b.label = 2;
+                                            _c.label = 2;
                                         case 2: return [2 /*return*/];
                                     }
                                 });
@@ -1084,7 +1214,7 @@ var BundleDataClient = /** @class */ (function () {
                         promises = [
                             validatedBundleV3Fills.length > 0
                                 ? this.clients.hubPoolClient.batchComputeRealizedLpFeePct(validatedBundleV3Fills.map(function (fill) {
-                                    var matchedDeposit = v3RelayHashes[_this.getRelayHashFromEvent(fill)].deposit;
+                                    var matchedDeposit = v3RelayHashes[_this.getRelayHashFromEvent(fill)].deposits[0];
                                     assert(isDefined(matchedDeposit), "Deposit should exist in relay hash dictionary.");
                                     var paymentChainId = getRefundInformationFromFill(fill, _this.clients.hubPoolClient, blockRangesForChains, chainIds, matchedDeposit.fromLiteChain).chainToSendRefundTo;
                                     return __assign(__assign({}, fill), { paymentChainId: paymentChainId });
@@ -1111,14 +1241,23 @@ var BundleDataClient = /** @class */ (function () {
                         v3FillLpFees.forEach(function (_a, idx) {
                             var realizedLpFeePct = _a.realizedLpFeePct;
                             var fill = validatedBundleV3Fills[idx];
-                            var associatedDeposit = v3RelayHashes[_this.getRelayHashFromEvent(fill)].deposit;
+                            var associatedDeposit = v3RelayHashes[_this.getRelayHashFromEvent(fill)].deposits[0];
                             assert(isDefined(associatedDeposit), "Deposit should exist in relay hash dictionary.");
                             var _b = getRefundInformationFromFill(fill, _this.clients.hubPoolClient, blockRangesForChains, chainIds, associatedDeposit.fromLiteChain), chainToSendRefundTo = _b.chainToSendRefundTo, repaymentToken = _b.repaymentToken;
-                            updateBundleFillsV3(bundleFillsV3, fill, realizedLpFeePct, chainToSendRefundTo, repaymentToken);
+                            updateBundleFillsV3(bundleFillsV3, fill, realizedLpFeePct, chainToSendRefundTo, repaymentToken, fill.relayer);
                         });
                         v3SlowFillLpFees.forEach(function (_a, idx) {
                             var lpFeePct = _a.realizedLpFeePct;
                             var 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.
+                            var relayDataHash = _this.getRelayHashFromEvent(deposit);
+                            if (validatedBundleSlowFills.slice(0, idx).some(function (d) { return _this.getRelayHashFromEvent(d) === relayDataHash; })) {
+                                return;
+                            }
+                            assert(!_depositIsExpired(deposit), "Cannot create slow fill leaf for expired deposit.");
                             updateBundleSlowFills(bundleSlowFillsV3, __assign(__assign({}, deposit), { lpFeePct: lpFeePct }));
                         });
                         v3UnexecutableSlowFillLpFees.forEach(function (_a, idx) {
@@ -1126,15 +1265,31 @@ var BundleDataClient = /** @class */ (function () {
                             var deposit = validatedBundleUnexecutableSlowFills[idx];
                             updateBundleExcessSlowFills(unexecutableSlowFills, __assign(__assign({}, deposit), { lpFeePct: lpFeePct }));
                         });
-                        v3SpokeEventsReadable = prettyPrintV3SpokePoolEvents(bundleDepositsV3, bundleFillsV3, bundleInvalidFillsV3, bundleSlowFillsV3, expiredDepositsToRefundV3, unexecutableSlowFills);
+                        v3SpokeEventsReadable = prettyPrintV3SpokePoolEvents(bundleDepositsV3, bundleFillsV3, bundleSlowFillsV3, expiredDepositsToRefundV3, unexecutableSlowFills);
                         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: blockRangesForChains,
                                 bundleInvalidFillsV3: 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: blockRangesForChains,
+                                bundleUnrepayableFillsV3: 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: blockRangesForChains,
+                                bundleInvalidSlowFillRequests: bundleInvalidSlowFillRequests,
+                            });
+                        }
                         this.logger.debug({
                             at: "BundleDataClient#loadDataFromScratch",
                             message: "Computed bundle data in ".concat(Math.round(performance.now() - start) / 1000, "s."),
@@ -1159,6 +1314,16 @@ var BundleDataClient = /** @class */ (function () {
     BundleDataClient.prototype.getRelayHashFromEvent = function (event) {
         return "".concat(event.depositor, "-").concat(event.recipient, "-").concat(event.exclusiveRelayer, "-").concat(event.inputToken, "-").concat(event.outputToken, "-").concat(event.inputAmount, "-").concat(event.outputAmount, "-").concat(event.originChainId, "-").concat(event.depositId.toString(), "-").concat(event.fillDeadline, "-").concat(event.exclusivityDeadline, "-").concat(event.message, "-").concat(event.destinationChainId);
     };
+    BundleDataClient.prototype.findMatchingFillEvent = function (deposit, spokePoolClient) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, findFillEvent(spokePoolClient.spokePool, deposit, spokePoolClient.deploymentBlock, spokePoolClient.latestBlockSearched)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     BundleDataClient.prototype.getBundleBlockTimestamps = function (chainIds, blockRangesForChains, spokePoolClients) {
         return __awaiter(this, void 0, void 0, function () {
             var _a, _b;
@@ -1168,7 +1333,7 @@ var BundleDataClient = /** @class */ (function () {
                     case 0:
                         _b = (_a = Object).fromEntries;
                         return [4 /*yield*/, mapAsync(chainIds, function (chainId, index) { return __awaiter(_this, void 0, void 0, function () {
-                                var blockRangeForChain, _startBlockForChain, _endBlockForChain, spokePoolClient, startBlockForChain, endBlockForChain, _a, startTime, endTime, _b;
+                                var blockRangeForChain, _startBlockForChain, _endBlockForChain, spokePoolClient, startBlockForChain, endBlockForChain, _a, startTime, _endTime, _b, endBlockDelta, endTime;
                                 return __generator(this, function (_c) {
                                     switch (_c.label) {
                                         case 0:
@@ -1183,7 +1348,7 @@ var BundleDataClient = /** @class */ (function () {
                                                 return [2 /*return*/];
                                             }
                                             startBlockForChain = Math.min(_startBlockForChain, spokePoolClient.latestBlockSearched);
-                                            endBlockForChain = Math.min(_endBlockForChain, spokePoolClient.latestBlockSearched);
+                                            endBlockForChain = Math.min(_endBlockForChain + 1, spokePoolClient.latestBlockSearched);
                                             return [4 /*yield*/, spokePoolClient.getTimestampForBlock(startBlockForChain)];
                                         case 1:
                                             _b = [
@@ -1193,9 +1358,11 @@ var BundleDataClient = /** @class */ (function () {
                                         case 2:
                                             _a = _b.concat([
                                                 _c.sent()
-                                            ]), startTime = _a[0], endTime = _a[1];
+                                            ]), startTime = _a[0], _endTime = _a[1];
+                                            endBlockDelta = endBlockForChain > startBlockForChain ? 1 : 0;
+                                            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 ".concat(endBlockForChain, " should be greater than start time for block ").concat(startBlockForChain, ": ").concat(endTime, " >= ").concat(startTime, "."));
                                             assert(startBlockForChain === 0 || startTime > 0, "Start timestamp must be greater than 0 if the start block is greater than 0.");
                                             return [2 /*return*/, [chainId, [startTime, endTime]]];
                                     }