@across-protocol/sdk 3.4.14 → 3.4.16

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

@@ -1,13 +1,17 @@
 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, } 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, chainIsEvm, isValidEvmAddress, } from "../../utils";
+import { _buildPoolRebalanceRoot, BundleDataSS, getEndBlockBuffers, getRefundInformationFromFill, getRefundsFromBundle, getWidestPossibleExpectedBlockRange, isChainDisabled, prettyPrintV3SpokePoolEvents, verifyFillRepayment, } from "./utils";
 // max(uint256) - 1
 export var INFINITE_FILL_DEADLINE = bnUint32Max;
 // V3 dictionary helper functions
 function updateExpiredDepositsV3(dict, deposit) {
     var _a;
+    // A deposit refund for a deposit is invalid if the depositor has a bytes32 address input for an EVM chain. It is valid otherwise.
+    if (chainIsEvm(deposit.originChainId) && !isValidEvmAddress(deposit.depositor)) {
+        return;
+    }
     var originChainId = deposit.originChainId, inputToken = deposit.inputToken;
     if (!((_a = dict === null || dict === void 0 ? void 0 : dict[originChainId]) === null || _a === void 0 ? void 0 : _a[inputToken])) {
         assign(dict, [originChainId, inputToken], []);
@@ -22,8 +26,12 @@ 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(repaymentChainId) && !isValidEvmAddress(repaymentAddress)) {
+        return;
+    }
     if (!((_a = dict === null || dict === void 0 ? void 0 : dict[repaymentChainId]) === null || _a === void 0 ? void 0 : _a[repaymentToken])) {
         assign(dict, [repaymentChainId, repaymentToken], {
             fills: [],
@@ -32,26 +40,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;
         }
     }
 }
@@ -209,77 +217,122 @@ 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);
-            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]) {
+                                                                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) {
@@ -371,33 +424,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."),
@@ -632,6 +692,8 @@ var BundleDataClient = /** @class */ (function () {
                                     }
                                     // If deposit block is within origin chain bundle block range, then save as bundle deposit.
                                     // If deposit is in bundle and it has expired, additionally save it as an expired deposit.
+                                    // Note: if the `depositor` field in the expired deposit is an invalid address, e.g. a bytes32 address on an EVM
+                                    // chain, then the deposit refund is invalid and ignored.
                                     // If deposit is not in the bundle block range, then save it as an older deposit that
                                     // may have expired.
                                     if (deposit.blockNumber >= originChainBlockRange[0] && deposit.blockNumber <= originChainBlockRange[1]) {
@@ -690,73 +752,87 @@ var BundleDataClient = /** @class */ (function () {
                                                                 // We can remove fills for deposits with input amount equal to zero because these will result in 0 refunded
                                                                 // 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] && !isZeroValueDeposit(fill); }), function (fill) { return __awaiter(_this, void 0, void 0, function () {
-                                                                var relayDataHash, historicalDeposit, matchedDeposit;
+                                                                .filter(function (fill) { return fill.blockNumber <= destinationChainBlockRange[1] && !isZeroValueDeposit(fill); }), function (_fill) { return __awaiter(_this, void 0, void 0, function () {
+                                                                var relayDataHash, fill, historicalDeposit, matchedDeposit, fill;
                                                                 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 &&
-                                                                                            !v3RelayHashes[relayDataHash].deposit.fromLiteChain &&
-                                                                                            !v3RelayHashes[relayDataHash].deposit.toLiteChain) {
-                                                                                            fastFillsReplacingSlowFills.push(relayDataHash);
-                                                                                        }
-                                                                                    }
-                                                                                }
+                                                                            relayDataHash = this.getRelayHashFromEvent(_fill);
+                                                                            if (!v3RelayHashes[relayDataHash]) return [3 /*break*/, 3];
+                                                                            if (!!v3RelayHashes[relayDataHash].fill) return [3 /*break*/, 2];
+                                                                            assert(isDefined(v3RelayHashes[relayDataHash].deposit), "Deposit should exist in relay hash dictionary.");
+                                                                            return [4 /*yield*/, verifyFillRepayment(_fill, destinationClient.spokePool.provider, v3RelayHashes[relayDataHash].deposit, allChainIds)];
+                                                                        case 1:
+                                                                            fill = _a.sent();
+                                                                            if (!isDefined(fill)) {
+                                                                                bundleInvalidFillsV3.push(_fill);
                                                                                 return [2 /*return*/];
                                                                             }
+                                                                            // 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 &&
+                                                                                    !v3RelayHashes[relayDataHash].deposit.fromLiteChain &&
+                                                                                    !v3RelayHashes[relayDataHash].deposit.toLiteChain) {
+                                                                                    fastFillsReplacingSlowFills.push(relayDataHash);
+                                                                                }
+                                                                            }
+                                                                            _a.label = 2;
+                                                                        case 2: return [2 /*return*/];
+                                                                        case 3:
                                                                             // At this point, there is no relay hash dictionary entry for this fill, so we need to
-                                                                            // instantiate the entry.
+                                                                            // instantiate the entry. We won't modify the fill.relayer until we match it with a deposit.
                                                                             v3RelayHashes[relayDataHash] = {
                                                                                 deposit: undefined,
-                                                                                fill: fill,
+                                                                                fill: _fill,
                                                                                 slowFillRequest: undefined,
                                                                             };
-                                                                            if (!(fill.blockNumber >= destinationChainBlockRange[0])) return [3 /*break*/, 2];
+                                                                            if (!(_fill.blockNumber >= destinationChainBlockRange[0])) return [3 /*break*/, 7];
                                                                             // 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.
-                                                                            if (!INFINITE_FILL_DEADLINE.eq(fill.fillDeadline)) {
-                                                                                bundleInvalidFillsV3.push(fill);
+                                                                            if (!INFINITE_FILL_DEADLINE.eq(_fill.fillDeadline)) {
+                                                                                bundleInvalidFillsV3.push(_fill);
                                                                                 return [2 /*return*/];
                                                                             }
-                                                                            return [4 /*yield*/, queryHistoricalDepositForFill(originClient, fill)];
-                                                                        case 1:
+                                                                            return [4 /*yield*/, queryHistoricalDepositForFill(originClient, _fill)];
+                                                                        case 4:
                                                                             historicalDeposit = _a.sent();
-                                                                            if (!historicalDeposit.found) {
-                                                                                bundleInvalidFillsV3.push(fill);
+                                                                            if (!!historicalDeposit.found) return [3 /*break*/, 5];
+                                                                            bundleInvalidFillsV3.push(_fill);
+                                                                            return [3 /*break*/, 7];
+                                                                        case 5:
+                                                                            matchedDeposit = historicalDeposit.deposit;
+                                                                            return [4 /*yield*/, verifyFillRepayment(_fill, destinationClient.spokePool.provider, matchedDeposit, allChainIds)];
+                                                                        case 6:
+                                                                            fill = _a.sent();
+                                                                            if (!isDefined(fill)) {
+                                                                                bundleInvalidFillsV3.push(_fill);
+                                                                                return [2 /*return*/];
                                                                             }
-                                                                            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 &&
-                                                                                    !matchedDeposit.fromLiteChain &&
-                                                                                    !matchedDeposit.toLiteChain) {
-                                                                                    fastFillsReplacingSlowFills.push(relayDataHash);
-                                                                                }
+                                                                            v3RelayHashes[relayDataHash].fill = fill;
+                                                                            // @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 &&
+                                                                                !matchedDeposit.fromLiteChain &&
+                                                                                !matchedDeposit.toLiteChain) {
+                                                                                fastFillsReplacingSlowFills.push(relayDataHash);
                                                                             }
-                                                                            _a.label = 2;
-                                                                        case 2: return [2 /*return*/];
+                                                                            _a.label = 7;
+                                                                        case 7: return [2 /*return*/];
                                                                     }
                                                                 });
                                                             }); })];
@@ -1025,7 +1101,7 @@ var BundleDataClient = /** @class */ (function () {
                             var associatedDeposit = v3RelayHashes[_this.getRelayHashFromEvent(fill)].deposit;
                             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;