@across-protocol/sdk 3.1.27 → 3.1.28

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

@@ -0,0 +1,1097 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import _ from "lodash";
+import { FillType, FillStatus, } from "../../interfaces";
+import { bnZero, queryHistoricalDepositForFill, assign, assert, fixedPointAdjustment, isDefined, toBN, forEachAsync, getBlockRangeForChain, getImpliedBundleBlockRanges, isSlowFill, mapAsync, relayFillStatus, bnUint32Max, } from "../../utils";
+import { BigNumber } from "ethers";
+import { _buildPoolRebalanceRoot, BundleDataSS, getEndBlockBuffers, getRefundInformationFromFill, getRefundsFromBundle, getWidestPossibleExpectedBlockRange, isChainDisabled, prettyPrintV3SpokePoolEvents, } from "./utils";
+// max(uint256) - 1
+export var INFINITE_FILL_DEADLINE = bnUint32Max;
+// V3 dictionary helper functions
+function updateExpiredDepositsV3(dict, deposit) {
+    var _a;
+    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], []);
+    }
+    dict[originChainId][inputToken].push(deposit);
+}
+function updateBundleDepositsV3(dict, deposit) {
+    var _a;
+    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], []);
+    }
+    dict[originChainId][inputToken].push(deposit);
+}
+function updateBundleFillsV3(dict, fill, lpFeePct, repaymentChainId, repaymentToken) {
+    var _a, _b;
+    if (!((_a = dict === null || dict === void 0 ? void 0 : dict[repaymentChainId]) === null || _a === void 0 ? void 0 : _a[repaymentToken])) {
+        assign(dict, [repaymentChainId, repaymentToken], {
+            fills: [],
+            totalRefundAmount: bnZero,
+            realizedLpFees: bnZero,
+            refunds: {},
+        });
+    }
+    var bundleFill = __assign(__assign({}, fill), { lpFeePct: lpFeePct });
+    // 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);
+    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);
+        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);
+        }
+        else {
+            refundObj.refunds[fill.relayer] = refundAmount;
+        }
+    }
+}
+function updateBundleExcessSlowFills(dict, deposit) {
+    var _a;
+    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], []);
+    }
+    dict[destinationChainId][outputToken].push(deposit);
+}
+function updateBundleSlowFills(dict, deposit) {
+    var _a;
+    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], []);
+    }
+    dict[destinationChainId][outputToken].push(deposit);
+}
+// @notice Shared client for computing data needed to construct or validate a bundle.
+var BundleDataClient = /** @class */ (function () {
+    // eslint-disable-next-line no-useless-constructor
+    function BundleDataClient(logger, clients, spokePoolClients, chainIdListForBundleEvaluationBlockNumbers, blockRangeEndBlockBuffer) {
+        if (blockRangeEndBlockBuffer === void 0) { blockRangeEndBlockBuffer = {}; }
+        this.logger = logger;
+        this.clients = clients;
+        this.spokePoolClients = spokePoolClients;
+        this.chainIdListForBundleEvaluationBlockNumbers = chainIdListForBundleEvaluationBlockNumbers;
+        this.blockRangeEndBlockBuffer = blockRangeEndBlockBuffer;
+        this.loadDataCache = {};
+        this.arweaveDataCache = {};
+        this.bundleTimestampCache = {};
+    }
+    // This should be called whenever it's possible that the loadData information for a block range could have changed.
+    // For instance, if the spoke or hub clients have been updated, it probably makes sense to clear this to be safe.
+    BundleDataClient.prototype.clearCache = function () {
+        this.loadDataCache = {};
+    };
+    BundleDataClient.prototype.loadDataFromCache = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _b = (_a = _).cloneDeep;
+                        return [4 /*yield*/, this.loadDataCache[key]];
+                    case 1: 
+                    // Always return a deep cloned copy of object stored in cache. Since JS passes by reference instead of value, we
+                    // want to minimize the risk that the programmer accidentally mutates data in the cache.
+                    return [2 /*return*/, _b.apply(_a, [_c.sent()])];
+                }
+            });
+        });
+    };
+    BundleDataClient.prototype.getBundleTimestampsFromCache = function (key) {
+        if (this.bundleTimestampCache[key]) {
+            return _.cloneDeep(this.bundleTimestampCache[key]);
+        }
+        return undefined;
+    };
+    BundleDataClient.prototype.setBundleTimestampsInCache = function (key, timestamps) {
+        this.bundleTimestampCache[key] = timestamps;
+    };
+    BundleDataClient.prototype.getArweaveClientKey = function (blockRangesForChains) {
+        return "bundles-".concat(blockRangesForChains);
+    };
+    BundleDataClient.prototype.loadPersistedDataFromArweave = function (blockRangesForChains) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var start, persistedData, convertTypedStringRecordIntoNumericRecord, data, bundleData;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!isDefined((_a = this.clients) === null || _a === void 0 ? void 0 : _a.arweaveClient)) {
+                            return [2 /*return*/, undefined];
+                        }
+                        start = performance.now();
+                        return [4 /*yield*/, this.clients.arweaveClient.getByTopic(this.getArweaveClientKey(blockRangesForChains), BundleDataSS)];
+                    case 1:
+                        persistedData = _b.sent();
+                        // If there is no data or the data is empty, return undefined because we couldn't
+                        // pull info from the Arweave persistence layer.
+                        if (!isDefined(persistedData) || persistedData.length < 1) {
+                            return [2 /*return*/, undefined];
+                        }
+                        convertTypedStringRecordIntoNumericRecord = function (data) {
+                            return Object.keys(data).reduce(function (acc, chainId) {
+                                acc[Number(chainId)] = data[chainId];
+                                return acc;
+                            }, {});
+                        };
+                        data = persistedData[0].data;
+                        bundleData = {
+                            bundleFillsV3: convertTypedStringRecordIntoNumericRecord(data.bundleFillsV3),
+                            expiredDepositsToRefundV3: convertTypedStringRecordIntoNumericRecord(data.expiredDepositsToRefundV3),
+                            bundleDepositsV3: convertTypedStringRecordIntoNumericRecord(data.bundleDepositsV3),
+                            unexecutableSlowFills: convertTypedStringRecordIntoNumericRecord(data.unexecutableSlowFills),
+                            bundleSlowFillsV3: convertTypedStringRecordIntoNumericRecord(data.bundleSlowFillsV3),
+                        };
+                        this.logger.debug({
+                            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),
+                        });
+                        return [2 /*return*/, bundleData];
+                }
+            });
+        });
+    };
+    // @dev This function should probably be moved to the InventoryClient since it bypasses loadData completely now.
+    BundleDataClient.prototype.getPendingRefundsFromValidBundles = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var refunds, bundle, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        refunds = [];
+                        if (!this.clients.hubPoolClient.isUpdated) {
+                            throw new Error("BundleDataClient::getPendingRefundsFromValidBundles HubPoolClient not updated.");
+                        }
+                        bundle = this.clients.hubPoolClient.getLatestFullyExecutedRootBundle(this.clients.hubPoolClient.latestBlockSearched);
+                        if (!(bundle !== undefined)) return [3 /*break*/, 2];
+                        _b = (_a = refunds).push;
+                        return [4 /*yield*/, this.getPendingRefundsFromBundle(bundle)];
+                    case 1:
+                        _b.apply(_a, [_c.sent()]);
+                        _c.label = 2;
+                    case 2: // No more valid bundles in history!
+                    return [2 /*return*/, refunds];
+                }
+            });
+        });
+    };
+    // @dev This function should probably be moved to the InventoryClient since it bypasses loadData completely now.
+    // Return refunds from input bundle.
+    BundleDataClient.prototype.getPendingRefundsFromBundle = function (bundle) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nextBundleMainnetStartBlock, chainIds, bundleEvaluationBlockRanges, combinedRefunds, arweaveData, bundleFillsV3, expiredDepositsToRefundV3;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        nextBundleMainnetStartBlock = this.clients.hubPoolClient.getNextBundleStartBlockNumber(this.chainIdListForBundleEvaluationBlockNumbers, this.clients.hubPoolClient.latestBlockSearched, this.clients.hubPoolClient.chainId);
+                        chainIds = this.clients.configStoreClient.getChainIdIndicesForBlock(nextBundleMainnetStartBlock);
+                        bundleEvaluationBlockRanges = getImpliedBundleBlockRanges(this.clients.hubPoolClient, this.clients.configStoreClient, bundle);
+                        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)];
+                }
+            });
+        });
+    };
+    // @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;
+                }
+                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) {
+            return toBN(0);
+        }
+        return this.spokePoolClients[chainId]
+            .getDeposits()
+            .filter(function (deposit) { return deposit.blockNumber > latestBlockToSearch && deposit.inputToken === l2Token; })
+            .reduce(function (acc, deposit) {
+            return acc.add(deposit.inputAmount);
+        }, toBN(0));
+    };
+    BundleDataClient.prototype.getLatestProposedBundleData = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var hubPoolClient, bundleBlockRanges;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        hubPoolClient = this.clients.hubPoolClient;
+                        bundleBlockRanges = getImpliedBundleBlockRanges(hubPoolClient, this.clients.configStoreClient, hubPoolClient.hasPendingProposal()
+                            ? hubPoolClient.getLatestProposedRootBundle()
+                            : hubPoolClient.getLatestFullyExecutedRootBundle(hubPoolClient.latestBlockSearched) // ! because we know there is a bundle
+                        );
+                        _a = {
+                            blockRanges: bundleBlockRanges
+                        };
+                        return [4 /*yield*/, this.loadData(bundleBlockRanges, this.spokePoolClients, true // this bundle data should have been published to arweave
+                            )];
+                    case 1: return [2 /*return*/, (_a.bundleData = _b.sent(),
+                            _a)];
+                }
+            });
+        });
+    };
+    BundleDataClient.prototype.getLatestPoolRebalanceRoot = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, bundleData, blockRanges, hubPoolClient, root;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getLatestProposedBundleData()];
+                    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();
+                        return [2 /*return*/, {
+                                root: root,
+                                blockRanges: blockRanges,
+                            }];
+                }
+            });
+        });
+    };
+    // @dev This function should probably be moved to the InventoryClient since it bypasses loadData completely now.
+    // Return refunds from the next valid bundle. This will contain any refunds that have been sent but are not included
+    // in a valid bundle with all of its leaves executed. This contains refunds from:
+    // - Bundles that passed liveness but have not had all of their pool rebalance leaves executed.
+    // - Bundles that are pending liveness
+    // - Fills sent after the pending, but not validated, bundle
+    BundleDataClient.prototype.getNextBundleRefunds = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            // Return block ranges for blocks after _pendingBlockRanges and up to widestBlockRanges.
+            // If a chain is disabled or doesn't have a spoke pool client, return a range of 0
+            function getBlockRangeDelta(_pendingBlockRanges) {
+                return widestBundleBlockRanges.map(function (blockRange, index) {
+                    var _a;
+                    // If pending block range doesn't have an entry for the widest range, which is possible when a new chain
+                    // is added to the CHAIN_ID_INDICES list, then simply set the initial block range to the widest block range.
+                    // This will produce a block range delta of 0 where the returned range for this chain is [widest[1], widest[1]].
+                    var initialBlockRange = (_a = _pendingBlockRanges[index]) !== null && _a !== void 0 ? _a : blockRange;
+                    // If chain is disabled, return disabled range
+                    if (initialBlockRange[0] === initialBlockRange[1]) {
+                        return initialBlockRange;
+                    }
+                    // If pending bundle end block exceeds widest end block or if widest end block is undefined
+                    // (which is possible if the spoke pool client for the chain is not defined), return an empty range since there are no
+                    // "new" events to consider for this chain.
+                    if (!isDefined(blockRange[1]) || initialBlockRange[1] >= blockRange[1]) {
+                        return [initialBlockRange[1], initialBlockRange[1]];
+                    }
+                    // If initialBlockRange][0] > widestBlockRange[0], then we'll ignore any blocks
+                    // between initialBlockRange[0] and widestBlockRange[0] (inclusive) for simplicity reasons. In practice
+                    // this should not happen.
+                    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) {
+                    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];
+                        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));
+                        }
+                        // Shorten the widestBundleBlockRanges now to not double count the pending bundle blocks.
+                        widestBundleBlockRanges = getBlockRangeDelta(pendingBundleBlockRanges);
+                        _a.label = 2;
+                    case 2:
+                        start = performance.now();
+                        combinedRefunds.push(this.getApproximateRefundsForBlockRange(chainIds, widestBundleBlockRanges));
+                        this.logger.debug({
+                            at: "BundleDataClient#getNextBundleRefunds",
+                            message: "Loading approximate refunds for next bundle in ".concat(Math.round(performance.now() - start) / 1000, "s."),
+                            blockRanges: JSON.stringify(widestBundleBlockRanges),
+                        });
+                        return [2 /*return*/, combinedRefunds];
+                }
+            });
+        });
+    };
+    // @dev This helper function should probably be moved to the InventoryClient
+    BundleDataClient.prototype.getExecutedRefunds = function (spokePoolClient, relayerRefundRoot) {
+        if (!isDefined(spokePoolClient)) {
+            return {};
+        }
+        // @dev Search from right to left since there can be multiple root bundles with the same relayer refund root.
+        // The caller should take caution if they're trying to use this function to find matching refunds for older
+        // root bundles as opposed to more recent ones.
+        var bundle = _.findLast(spokePoolClient.getRootBundleRelays(), function (bundle) { return bundle.relayerRefundRoot === relayerRefundRoot; });
+        if (bundle === undefined) {
+            return {};
+        }
+        var executedRefundLeaves = spokePoolClient
+            .getRelayerRefundExecutions()
+            .filter(function (leaf) { return leaf.rootBundleId === bundle.rootBundleId; });
+        var executedRefunds = {};
+        for (var _i = 0, executedRefundLeaves_1 = executedRefundLeaves; _i < executedRefundLeaves_1.length; _i++) {
+            var refundLeaf = executedRefundLeaves_1[_i];
+            var tokenAddress = refundLeaf.l2TokenAddress;
+            if (executedRefunds[tokenAddress] === undefined) {
+                executedRefunds[tokenAddress] = {};
+            }
+            var executedTokenRefunds = executedRefunds[tokenAddress];
+            for (var i = 0; i < refundLeaf.refundAddresses.length; i++) {
+                var relayer = refundLeaf.refundAddresses[i];
+                var refundAmount = refundLeaf.refundAmounts[i];
+                if (executedTokenRefunds[relayer] === undefined) {
+                    executedTokenRefunds[relayer] = bnZero;
+                }
+                executedTokenRefunds[relayer] = executedTokenRefunds[relayer].add(refundAmount);
+            }
+        }
+        return executedRefunds;
+    };
+    // @dev This helper function should probably be moved to the InventoryClient
+    BundleDataClient.prototype.deductExecutedRefunds = function (allRefunds, bundleContainingRefunds) {
+        for (var _i = 0, _a = Object.keys(allRefunds); _i < _a.length; _i++) {
+            var chainIdStr = _a[_i];
+            var chainId = Number(chainIdStr);
+            if (!isDefined(this.spokePoolClients[chainId])) {
+                continue;
+            }
+            var executedRefunds = this.getExecutedRefunds(this.spokePoolClients[chainId], bundleContainingRefunds.relayerRefundRoot);
+            for (var _b = 0, _c = Object.keys(allRefunds[chainId]); _b < _c.length; _b++) {
+                var tokenAddress = _c[_b];
+                var refunds = allRefunds[chainId][tokenAddress];
+                if (executedRefunds[tokenAddress] === undefined || refunds === undefined) {
+                    continue;
+                }
+                for (var _d = 0, _e = Object.keys(refunds); _d < _e.length; _d++) {
+                    var relayer = _e[_d];
+                    var executedAmount = executedRefunds[tokenAddress][relayer];
+                    if (executedAmount === undefined) {
+                        continue;
+                    }
+                    // Since there should only be a single executed relayer refund leaf for each relayer-token-chain combination,
+                    // we can deduct this refund and mark it as executed if the executed amount is > 0.
+                    refunds[relayer] = bnZero;
+                }
+            }
+        }
+        return allRefunds;
+    };
+    BundleDataClient.prototype.getRefundsFor = function (bundleRefunds, relayer, chainId, token) {
+        if (!bundleRefunds[chainId] || !bundleRefunds[chainId][token]) {
+            return BigNumber.from(0);
+        }
+        var allRefunds = bundleRefunds[chainId][token];
+        return allRefunds && allRefunds[relayer] ? allRefunds[relayer] : BigNumber.from(0);
+    };
+    BundleDataClient.prototype.getTotalRefund = function (refunds, relayer, chainId, refundToken) {
+        var _this = this;
+        return refunds.reduce(function (totalRefund, refunds) {
+            return totalRefund.add(_this.getRefundsFor(refunds, relayer, chainId, refundToken));
+        }, bnZero);
+    };
+    BundleDataClient.prototype.loadArweaveData = function (blockRangesForChains) {
+        return __awaiter(this, void 0, void 0, function () {
+            var arweaveKey, arweaveData, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        arweaveKey = this.getArweaveClientKey(blockRangesForChains);
+                        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                        if (!this.arweaveDataCache[arweaveKey]) {
+                            this.arweaveDataCache[arweaveKey] = this.loadPersistedDataFromArweave(blockRangesForChains);
+                        }
+                        _b = (_a = _).cloneDeep;
+                        return [4 /*yield*/, this.arweaveDataCache[arweaveKey]];
+                    case 1:
+                        arweaveData = _b.apply(_a, [_c.sent()]);
+                        return [2 /*return*/, arweaveData];
+                }
+            });
+        });
+    };
+    // Common data re-formatting logic shared across all data worker public functions.
+    // User must pass in spoke pool to search event data against. This allows the user to refund relays and fill deposits
+    // on deprecated spoke pools.
+    BundleDataClient.prototype.loadData = function (blockRangesForChains, spokePoolClients, attemptArweaveLoad) {
+        if (attemptArweaveLoad === void 0) { attemptArweaveLoad = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var key, arweaveData, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        key = JSON.stringify(blockRangesForChains);
+                        if (!!this.loadDataCache[key]) return [3 /*break*/, 4];
+                        arweaveData = void 0;
+                        if (!attemptArweaveLoad) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.loadArweaveData(blockRangesForChains)];
+                    case 1:
+                        arweaveData = _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        arweaveData = undefined;
+                        _a.label = 3;
+                    case 3:
+                        data = isDefined(arweaveData)
+                            ? // We can return the data to a Promise to keep the return type consistent.
+                                // Note: this is now a fast operation since we've already loaded the data from Arweave.
+                                Promise.resolve(arweaveData)
+                            : this.loadDataFromScratch(blockRangesForChains, spokePoolClients);
+                        this.loadDataCache[key] = data;
+                        _a.label = 4;
+                    case 4: return [2 /*return*/, this.loadDataFromCache(key)];
+                }
+            });
+        });
+    };
+    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, allChainIds, _cachedBundleTimestamps, bundleBlockTimestamps, v3RelayHashes, expiredBundleDepositHashes, olderDepositHashes, depositCounter, _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) {
+                    case 0:
+                        start = performance.now();
+                        key = JSON.stringify(blockRangesForChains);
+                        if (!this.clients.configStoreClient.isUpdated) {
+                            throw new Error("ConfigStoreClient not updated");
+                        }
+                        else if (!this.clients.hubPoolClient.isUpdated) {
+                            throw new Error("HubPoolClient not updated");
+                        }
+                        chainIds = this.clients.configStoreClient.getChainIdIndicesForBlock(blockRangesForChains[0][0]);
+                        if (blockRangesForChains.length > chainIds.length) {
+                            throw new Error("Unexpected block range list length of ".concat(blockRangesForChains.length, ", should be <= ").concat(chainIds.length));
+                        }
+                        bundleDepositsV3 = {};
+                        bundleFillsV3 = {};
+                        bundleInvalidFillsV3 = [];
+                        bundleSlowFillsV3 = {};
+                        expiredDepositsToRefundV3 = {};
+                        unexecutableSlowFills = {};
+                        _isChainDisabled = function (chainId) {
+                            var blockRangeForChain = getBlockRangeForChain(blockRangesForChains, chainId, chainIds);
+                            return isChainDisabled(blockRangeForChain);
+                        };
+                        allChainIds = blockRangesForChains
+                            .map(function (_blockRange, index) { return chainIds[index]; })
+                            .filter(function (chainId) { return !_isChainDisabled(chainId) && spokePoolClients[chainId] !== undefined; });
+                        allChainIds.forEach(function (chainId) {
+                            var spokePoolClient = spokePoolClients[chainId];
+                            if (!spokePoolClient.isUpdated) {
+                                throw new Error("SpokePoolClient for chain ".concat(chainId, " not updated."));
+                            }
+                        });
+                        _cachedBundleTimestamps = this.getBundleTimestampsFromCache(key);
+                        bundleBlockTimestamps = {};
+                        if (!!_cachedBundleTimestamps) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getBundleBlockTimestamps(chainIds, blockRangesForChains, spokePoolClients)];
+                    case 1:
+                        bundleBlockTimestamps = _c.sent();
+                        this.setBundleTimestampsInCache(key, bundleBlockTimestamps);
+                        this.logger.debug({
+                            at: "BundleDataClient#loadData",
+                            message: "Bundle block timestamps",
+                            bundleBlockTimestamps: bundleBlockTimestamps,
+                            blockRangesForChains: JSON.stringify(blockRangesForChains),
+                        });
+                        return [3 /*break*/, 3];
+                    case 2:
+                        bundleBlockTimestamps = _cachedBundleTimestamps;
+                        _c.label = 3;
+                    case 3:
+                        v3RelayHashes = {};
+                        expiredBundleDepositHashes = new Set();
+                        olderDepositHashes = new Set();
+                        depositCounter = 0;
+                        _loop_2 = function (originChainId) {
+                            var originClient = spokePoolClients[originChainId];
+                            var originChainBlockRange = getBlockRangeForChain(blockRangesForChains, originChainId, chainIds);
+                            var _loop_4 = function (destinationChainId) {
+                                if (originChainId === destinationChainId) {
+                                    return "continue";
+                                }
+                                originClient.getDepositsForDestinationChain(destinationChainId).forEach(function (deposit) {
+                                    depositCounter++;
+                                    var relayDataHash = _this.getRelayHashFromEvent(deposit);
+                                    if (v3RelayHashes[relayDataHash]) {
+                                        // If we've seen this deposit before, then skip this deposit. This can happen if our RPC provider
+                                        // gives us bad data.
+                                        return;
+                                    }
+                                    // Even if deposit is not in bundle block range, store all deposits we can see in memory in this
+                                    // convenient dictionary.
+                                    v3RelayHashes[relayDataHash] = {
+                                        deposit: deposit,
+                                        fill: undefined,
+                                        slowFillRequest: undefined,
+                                    };
+                                    // 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.
+                                    // If deposit is not in the bundle block range, then save it as an older deposit that
+                                    // may have expired.
+                                    if (deposit.blockNumber >= originChainBlockRange[0] && deposit.blockNumber <= originChainBlockRange[1]) {
+                                        // Deposit is a V3 deposit in this origin chain's bundle block range and is not a duplicate.
+                                        updateBundleDepositsV3(bundleDepositsV3, deposit);
+                                        // We don't check that fillDeadline >= bundleBlockTimestamps[destinationChainId][0] because
+                                        // that would eliminate any deposits in this bundle with a very low fillDeadline like equal to 0
+                                        // for example. Those should be impossible to create but technically should be included in this
+                                        // bundle of refunded deposits.
+                                        if (deposit.fillDeadline < bundleBlockTimestamps[destinationChainId][1]) {
+                                            expiredBundleDepositHashes.add(relayDataHash);
+                                        }
+                                    }
+                                    else if (deposit.blockNumber < originChainBlockRange[0]) {
+                                        olderDepositHashes.add(relayDataHash);
+                                    }
+                                });
+                            };
+                            for (var _d = 0, allChainIds_3 = allChainIds; _d < allChainIds_3.length; _d++) {
+                                var destinationChainId = allChainIds_3[_d];
+                                _loop_4(destinationChainId);
+                            }
+                        };
+                        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."),
+                        });
+                        start = performance.now();
+                        validatedBundleV3Fills = [];
+                        validatedBundleSlowFills = [];
+                        validatedBundleUnexecutableSlowFills = [];
+                        fillCounter = 0;
+                        _loop_3 = function (originChainId) {
+                            var originClient, _loop_5, _e, allChainIds_4, destinationChainId;
+                            return __generator(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0:
+                                        originClient = spokePoolClients[originChainId];
+                                        _loop_5 = function (destinationChainId) {
+                                            var destinationClient, destinationChainBlockRange, fastFillsReplacingSlowFills;
+                                            return __generator(this, function (_g) {
+                                                switch (_g.label) {
+                                                    case 0:
+                                                        if (originChainId === destinationChainId) {
+                                                            return [2 /*return*/, "continue"];
+                                                        }
+                                                        destinationClient = spokePoolClients[destinationChainId];
+                                                        destinationChainBlockRange = getBlockRangeForChain(blockRangesForChains, destinationChainId, chainIds);
+                                                        fastFillsReplacingSlowFills = [];
+                                                        return [4 /*yield*/, forEachAsync(destinationClient
+                                                                .getFillsForOriginChain(originChainId)
+                                                                .filter(function (fill) { return fill.blockNumber <= destinationChainBlockRange[1]; }), function (fill) { return __awaiter(_this, void 0, void 0, function () {
+                                                                var relayDataHash, historicalDeposit, matchedDeposit;
+                                                                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.
+                                                                                        if (fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill) {
+                                                                                            fastFillsReplacingSlowFills.push(relayDataHash);
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                return [2 /*return*/];
+                                                                            }
+                                                                            // At this point, there is no relay hash dictionary entry for this fill, so we need to
+                                                                            // instantiate the entry.
+                                                                            v3RelayHashes[relayDataHash] = {
+                                                                                deposit: undefined,
+                                                                                fill: fill,
+                                                                                slowFillRequest: undefined,
+                                                                            };
+                                                                            if (!(fill.blockNumber >= destinationChainBlockRange[0])) return [3 /*break*/, 2];
+                                                                            // 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);
+                                                                                return [2 /*return*/];
+                                                                            }
+                                                                            return [4 /*yield*/, queryHistoricalDepositForFill(originClient, fill)];
+                                                                        case 1:
+                                                                            historicalDeposit = _a.sent();
+                                                                            if (!historicalDeposit.found) {
+                                                                                bundleInvalidFillsV3.push(fill);
+                                                                            }
+                                                                            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;
+                                                                                if (fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill) {
+                                                                                    fastFillsReplacingSlowFills.push(relayDataHash);
+                                                                                }
+                                                                            }
+                                                                            _a.label = 2;
+                                                                        case 2: return [2 /*return*/];
+                                                                    }
+                                                                });
+                                                            }); })];
+                                                    case 1:
+                                                        _g.sent();
+                                                        return [4 /*yield*/, forEachAsync(destinationClient
+                                                                .getSlowFillRequestsForOriginChain(originChainId)
+                                                                .filter(function (request) { return request.blockNumber <= destinationChainBlockRange[1]; }), function (slowFillRequest) { return __awaiter(_this, void 0, void 0, function () {
+                                                                var relayDataHash, matchedDeposit, historicalDeposit, matchedDeposit;
+                                                                var _a, _b;
+                                                                return __generator(this, function (_c) {
+                                                                    switch (_c.label) {
+                                                                        case 0:
+                                                                            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.
+                                                                                        return [2 /*return*/];
+                                                                                    }
+                                                                                    assert(isDefined(v3RelayHashes[relayDataHash].deposit), "Deposit should exist in relay hash dictionary.");
+                                                                                    matchedDeposit = v3RelayHashes[relayDataHash].deposit;
+                                                                                    // Input and Output tokens must be equivalent on the deposit for this to be slow filled.
+                                                                                    if (!this.clients.hubPoolClient.areTokensEquivalent(matchedDeposit.inputToken, matchedDeposit.originChainId, matchedDeposit.outputToken, matchedDeposit.destinationChainId, matchedDeposit.quoteBlockNumber)) {
+                                                                                        return [2 /*return*/];
+                                                                                    }
+                                                                                    // slow fill requests for deposits from or to lite chains are considered invalid
+                                                                                    if (((_a = v3RelayHashes[relayDataHash].deposit) === null || _a === void 0 ? void 0 : _a.fromLiteChain) ||
+                                                                                        ((_b = v3RelayHashes[relayDataHash].deposit) === null || _b === void 0 ? void 0 : _b.toLiteChain)) {
+                                                                                        return [2 /*return*/];
+                                                                                    }
+                                                                                    // If there is no fill matching the relay hash, then this might be a valid slow fill request
+                                                                                    // that we should produce a slow fill leaf for. Check if the slow fill request is in the
+                                                                                    // destination chain block range and that the underlying deposit has not expired yet.
+                                                                                    if (slowFillRequest.blockNumber >= destinationChainBlockRange[0] &&
+                                                                                        // Deposit must not have expired in this bundle.
+                                                                                        slowFillRequest.fillDeadline >= bundleBlockTimestamps[destinationChainId][1]) {
+                                                                                        // At this point, the v3RelayHashes entry already existed meaning that there is a matching deposit,
+                                                                                        // so this slow fill request relay data is correct.
+                                                                                        validatedBundleSlowFills.push(matchedDeposit);
+                                                                                    }
+                                                                                }
+                                                                                return [2 /*return*/];
+                                                                            }
+                                                                            // Instantiate dictionary if there is neither a deposit nor fill matching it.
+                                                                            v3RelayHashes[relayDataHash] = {
+                                                                                deposit: undefined,
+                                                                                fill: undefined,
+                                                                                slowFillRequest: slowFillRequest,
+                                                                            };
+                                                                            if (!(INFINITE_FILL_DEADLINE.eq(slowFillRequest.fillDeadline) &&
+                                                                                slowFillRequest.blockNumber >= destinationChainBlockRange[0])) return [3 /*break*/, 2];
+                                                                            return [4 /*yield*/, queryHistoricalDepositForFill(originClient, slowFillRequest)];
+                                                                        case 1:
+                                                                            historicalDeposit = _c.sent();
+                                                                            if (!historicalDeposit.found) {
+                                                                                // TODO: Invalid slow fill request. Maybe worth logging.
+                                                                                return [2 /*return*/];
+                                                                            }
+                                                                            matchedDeposit = historicalDeposit.deposit;
+                                                                            // @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.");
+                                                                            // slow fill requests for deposits from or to lite chains are considered invalid
+                                                                            if (matchedDeposit.fromLiteChain || matchedDeposit.toLiteChain) {
+                                                                                return [2 /*return*/];
+                                                                            }
+                                                                            v3RelayHashes[relayDataHash].deposit = matchedDeposit;
+                                                                            // Note: we don't need to query for a historical fill at this point because a fill
+                                                                            // cannot precede a slow fill request and if the fill came after the slow fill request,
+                                                                            // we would have seen it already because we would have processed it in the loop above.
+                                                                            if (
+                                                                            // Input and Output tokens must be equivalent on the deposit for this to be slow filled.
+                                                                            !this.clients.hubPoolClient.areTokensEquivalent(matchedDeposit.inputToken, matchedDeposit.originChainId, matchedDeposit.outputToken, matchedDeposit.destinationChainId, matchedDeposit.quoteBlockNumber) ||
+                                                                                // Deposit must not have expired in this bundle.
+                                                                                slowFillRequest.fillDeadline < bundleBlockTimestamps[destinationChainId][1]) {
+                                                                                // TODO: Invalid slow fill request. Maybe worth logging.
+                                                                                return [2 /*return*/];
+                                                                            }
+                                                                            validatedBundleSlowFills.push(matchedDeposit);
+                                                                            _c.label = 2;
+                                                                        case 2: return [2 /*return*/];
+                                                                    }
+                                                                });
+                                                            }); })];
+                                                    case 2:
+                                                        _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;
+                                                            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) {
+                                                                throw new Error("Deposit should exist in relay hash dictionary.");
+                                                            }
+                                                            var destinationBlockRange = getBlockRangeForChain(blockRangesForChains, destinationChainId, chainIds);
+                                                            if (
+                                                            // If the slow fill request that was replaced by this fill was in an older bundle, then we don't
+                                                            // need to check if the slow fill request was valid since we can assume all bundles in the past
+                                                            // were validated. However, we might as well double check.
+                                                            _this.clients.hubPoolClient.areTokensEquivalent(deposit.inputToken, deposit.originChainId, deposit.outputToken, deposit.destinationChainId, deposit.quoteBlockNumber) &&
+                                                                // If there is a slow fill request in this bundle that matches the relay hash, then there was no slow fill
+                                                                // created that would be considered excess.
+                                                                (!slowFillRequest || slowFillRequest.blockNumber < destinationBlockRange[0])) {
+                                                                validatedBundleUnexecutableSlowFills.push(deposit);
+                                                            }
+                                                        });
+                                                        return [2 /*return*/];
+                                                }
+                                            });
+                                        };
+                                        _e = 0, allChainIds_4 = allChainIds;
+                                        _f.label = 1;
+                                    case 1:
+                                        if (!(_e < allChainIds_4.length)) return [3 /*break*/, 4];
+                                        destinationChainId = allChainIds_4[_e];
+                                        return [5 /*yield**/, _loop_5(destinationChainId)];
+                                    case 2:
+                                        _f.sent();
+                                        _f.label = 3;
+                                    case 3:
+                                        _e++;
+                                        return [3 /*break*/, 1];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        _a = 0, allChainIds_2 = allChainIds;
+                        _c.label = 4;
+                    case 4:
+                        if (!(_a < allChainIds_2.length)) return [3 /*break*/, 7];
+                        originChainId = allChainIds_2[_a];
+                        return [5 /*yield**/, _loop_3(originChainId)];
+                    case 5:
+                        _c.sent();
+                        _c.label = 6;
+                    case 6:
+                        _a++;
+                        return [3 /*break*/, 4];
+                    case 7:
+                        this.logger.debug({
+                            at: "BundleDataClient#loadData",
+                            message: "Processed ".concat(fillCounter, " fills in ").concat(performance.now() - start, "ms."),
+                        });
+                        start = performance.now();
+                        // Go through expired deposits in this bundle and now prune those that we have seen a fill for to construct
+                        // the list of expired deposits we need to refund in this bundle.
+                        expiredBundleDepositHashes.forEach(function (relayDataHash) {
+                            var _a = v3RelayHashes[relayDataHash], deposit = _a.deposit, fill = _a.fill;
+                            assert(isDefined(deposit), "Deposit should exist in relay hash dictionary.");
+                            if (!fill &&
+                                isDefined(deposit) // Needed for TSC - we check this above.
+                            ) {
+                                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
+                            }
+                        });
+                        // For all deposits older than this bundle, we need to check if they expired in this bundle and if they did,
+                        // whether there was a slow fill created for it in a previous bundle that is now unexecutable and replaced
+                        // by a new expired deposit refund.
+                        return [4 /*yield*/, forEachAsync(Array.from(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) {
+                                        case 0:
+                                            _a = v3RelayHashes[relayDataHash], deposit = _a.deposit, slowFillRequest = _a.slowFillRequest, fill = _a.fill;
+                                            assert(isDefined(deposit), "Deposit should exist in relay hash dictionary.");
+                                            destinationChainId = deposit.destinationChainId;
+                                            destinationBlockRange = getBlockRangeForChain(blockRangesForChains, destinationChainId, chainIds);
+                                            if (!
+                                            // If there is a valid fill that we saw matching this deposit, then it does not need a refund.
+                                            (!fill &&
+                                                isDefined(deposit) && // Needed for TSC - we check this above.
+                                                deposit.fillDeadline < bundleBlockTimestamps[destinationChainId][1] &&
+                                                deposit.fillDeadline >= bundleBlockTimestamps[destinationChainId][0] &&
+                                                spokePoolClients[destinationChainId] !== undefined)) 
+                                            // If there is a valid fill that we saw matching this deposit, then it does not need a refund.
+                                            return [3 /*break*/, 2];
+                                            return [4 /*yield*/, relayFillStatus(spokePoolClients[destinationChainId].spokePool, deposit, 
+                                                // We can assume that in production
+                                                // the block ranges passed into this function would never contain blocks where the spoke pool client
+                                                // hasn't queried. This is because this function will usually be called
+                                                // in production with block ranges that were validated by
+                                                // DataworkerUtils.blockRangesAreInvalidForSpokeClients
+                                                Math.min(destinationBlockRange[1], spokePoolClients[destinationChainId].latestBlockSearched), destinationChainId)];
+                                        case 1:
+                                            fillStatus = _b.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) {
+                                                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
+                                            }
+                                            // If fill status is RequestedSlowFill, then we might need to mark down an unexecutable
+                                            // slow fill that we're going to replace with an expired deposit refund.
+                                            // If deposit cannot be slow filled, then exit early.
+                                            if (fillStatus !== FillStatus.RequestedSlowFill) {
+                                                return [2 /*return*/];
+                                            }
+                                            // Now, check if there was a slow fill created for this deposit in a previous bundle which would now be
+                                            // unexecutable. Mark this deposit as having created an unexecutable slow fill if there is no matching
+                                            // slow fill request or the matching slow fill request took place in a previous bundle.
+                                            // If there is a slow fill request in this bundle, then the expired deposit refund will supercede
+                                            // the slow fill request. If there is no slow fill request seen or its older than this bundle, then we can
+                                            // assume a slow fill leaf was created for it because its tokens are equivalent. The slow fill request was
+                                            // also sent before the fill deadline expired since we checked that above.
+                                            if (
+                                            // Since this deposit was requested for a slow fill in an older bundle at this point, we don't
+                                            // technically need to check if the slow fill request was valid since we can assume all bundles in the past
+                                            // were validated. However, we might as well double check.
+                                            this.clients.hubPoolClient.areTokensEquivalent(deposit.inputToken, deposit.originChainId, deposit.outputToken, deposit.destinationChainId, deposit.quoteBlockNumber) &&
+                                                (!slowFillRequest || slowFillRequest.blockNumber < destinationBlockRange[0])) {
+                                                validatedBundleUnexecutableSlowFills.push(deposit);
+                                            }
+                                            _b.label = 2;
+                                        case 2: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 8:
+                        // 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.
+                        _c.sent();
+                        // Batch compute V3 lp fees.
+                        start = performance.now();
+                        promises = [
+                            validatedBundleV3Fills.length > 0
+                                ? this.clients.hubPoolClient.batchComputeRealizedLpFeePct(validatedBundleV3Fills.map(function (fill) {
+                                    var matchedDeposit = v3RelayHashes[_this.getRelayHashFromEvent(fill)].deposit;
+                                    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 });
+                                }))
+                                : [],
+                            validatedBundleSlowFills.length > 0
+                                ? this.clients.hubPoolClient.batchComputeRealizedLpFeePct(validatedBundleSlowFills.map(function (deposit) {
+                                    return __assign(__assign({}, deposit), { paymentChainId: deposit.destinationChainId });
+                                }))
+                                : [],
+                            validatedBundleUnexecutableSlowFills.length > 0
+                                ? this.clients.hubPoolClient.batchComputeRealizedLpFeePct(validatedBundleUnexecutableSlowFills.map(function (deposit) {
+                                    return __assign(__assign({}, deposit), { paymentChainId: deposit.destinationChainId });
+                                }))
+                                : [],
+                        ];
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 9:
+                        _b = _c.sent(), v3FillLpFees = _b[0], v3SlowFillLpFees = _b[1], v3UnexecutableSlowFillLpFees = _b[2];
+                        this.logger.debug({
+                            at: "BundleDataClient#loadData",
+                            message: "Computed batch async LP fees in ".concat(performance.now() - start, "ms."),
+                        });
+                        v3FillLpFees.forEach(function (_a, idx) {
+                            var realizedLpFeePct = _a.realizedLpFeePct;
+                            var fill = validatedBundleV3Fills[idx];
+                            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);
+                        });
+                        v3SlowFillLpFees.forEach(function (_a, idx) {
+                            var lpFeePct = _a.realizedLpFeePct;
+                            var deposit = validatedBundleSlowFills[idx];
+                            updateBundleSlowFills(bundleSlowFillsV3, __assign(__assign({}, deposit), { lpFeePct: lpFeePct }));
+                        });
+                        v3UnexecutableSlowFillLpFees.forEach(function (_a, idx) {
+                            var lpFeePct = _a.realizedLpFeePct;
+                            var deposit = validatedBundleUnexecutableSlowFills[idx];
+                            updateBundleExcessSlowFills(unexecutableSlowFills, __assign(__assign({}, deposit), { lpFeePct: lpFeePct }));
+                        });
+                        v3SpokeEventsReadable = prettyPrintV3SpokePoolEvents(bundleDepositsV3, bundleFillsV3, bundleInvalidFillsV3, 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",
+                                blockRangesForChains: blockRangesForChains,
+                                bundleInvalidFillsV3: bundleInvalidFillsV3,
+                            });
+                        }
+                        this.logger.debug({
+                            at: "BundleDataClient#loadDataFromScratch",
+                            message: "Computed bundle data in ".concat(Math.round(performance.now() - start) / 1000, "s."),
+                            blockRangesForChains: JSON.stringify(blockRangesForChains),
+                            v3SpokeEventsReadable: v3SpokeEventsReadable,
+                        });
+                        return [2 /*return*/, {
+                                bundleDepositsV3: bundleDepositsV3,
+                                expiredDepositsToRefundV3: expiredDepositsToRefundV3,
+                                bundleFillsV3: bundleFillsV3,
+                                unexecutableSlowFills: unexecutableSlowFills,
+                                bundleSlowFillsV3: bundleSlowFillsV3,
+                            }];
+                }
+            });
+        });
+    };
+    // Internal function to uniquely identify a bridge event. This is preferred over `SDK.getRelayDataHash` which returns
+    // keccak256 hash of the relay data, which can be used as input into the on-chain `fillStatuses()` function in the
+    // spoke pool contract. However, this internal function is used to uniquely identify a bridging event
+    // for speed since its easier to build a string from the event data than to hash it.
+    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, "-").concat(event.fillDeadline, "-").concat(event.exclusivityDeadline, "-").concat(event.message, "-").concat(event.destinationChainId);
+    };
+    BundleDataClient.prototype.getBundleBlockTimestamps = function (chainIds, blockRangesForChains, spokePoolClients) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    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, _c, _d;
+                                return __generator(this, function (_e) {
+                                    switch (_e.label) {
+                                        case 0:
+                                            blockRangeForChain = blockRangesForChains[index];
+                                            if (!isDefined(blockRangeForChain) || isChainDisabled(blockRangeForChain)) {
+                                                return [2 /*return*/];
+                                            }
+                                            _startBlockForChain = blockRangeForChain[0], _endBlockForChain = blockRangeForChain[1];
+                                            spokePoolClient = spokePoolClients[chainId];
+                                            // Relayer instances using the BundleDataClient for repayment estimates may only relay on a subset of chains.
+                                            if (!isDefined(spokePoolClient)) {
+                                                return [2 /*return*/];
+                                            }
+                                            startBlockForChain = Math.min(_startBlockForChain, spokePoolClient.latestBlockSearched);
+                                            endBlockForChain = Math.min(_endBlockForChain, spokePoolClient.latestBlockSearched);
+                                            _b = Number;
+                                            return [4 /*yield*/, spokePoolClient.spokePool.provider.getBlock(startBlockForChain)];
+                                        case 1:
+                                            _c = [
+                                                _b.apply(void 0, [(_e.sent()).timestamp])
+                                            ];
+                                            _d = Number;
+                                            return [4 /*yield*/, spokePoolClient.spokePool.provider.getBlock(endBlockForChain)];
+                                        case 2:
+                                            _a = _c.concat([
+                                                _d.apply(void 0, [(_e.sent()).timestamp])
+                                            ]), startTime = _a[0], endTime = _a[1];
+                                            // Sanity checks:
+                                            assert(endTime >= startTime, "End time should be greater than start time.");
+                                            assert(startTime > 0, "Start time should be greater than 0.");
+                                            return [2 /*return*/, [chainId, [startTime, endTime]]];
+                                    }
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _b.apply(_a, [(_c.sent()).filter(isDefined)])];
+                }
+            });
+        });
+    };
+    return BundleDataClient;
+}());
+export { BundleDataClient };
+//# sourceMappingURL=BundleDataClient.js.map