@across-protocol/sdk 3.1.27 → 3.1.28

package/dist/cjs/clients/BundleDataClient/BundleDataClient.js

@@ -0,0 +1,929 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleDataClient = exports.INFINITE_FILL_DEADLINE = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = tslib_1.__importDefault(require("lodash"));
+var interfaces_1 = require("../../interfaces");
+var utils_1 = require("../../utils");
+var ethers_1 = require("ethers");
+var utils_2 = require("./utils");
+exports.INFINITE_FILL_DEADLINE = utils_1.bnUint32Max;
+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])) {
+        (0, utils_1.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])) {
+        (0, utils_1.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])) {
+        (0, utils_1.assign)(dict, [repaymentChainId, repaymentToken], {
+            fills: [],
+            totalRefundAmount: utils_1.bnZero,
+            realizedLpFees: utils_1.bnZero,
+            refunds: {},
+        });
+    }
+    var bundleFill = tslib_1.__assign(tslib_1.__assign({}, fill), { lpFeePct: lpFeePct });
+    (0, utils_1.assign)(dict, [repaymentChainId, repaymentToken, "fills"], [bundleFill]);
+    var refundObj = dict[repaymentChainId][repaymentToken];
+    var realizedLpFee = fill.inputAmount.mul(bundleFill.lpFeePct).div(utils_1.fixedPointAdjustment);
+    refundObj.realizedLpFees = refundObj.realizedLpFees ? refundObj.realizedLpFees.add(realizedLpFee) : realizedLpFee;
+    if (!(0, utils_1.isSlowFill)(fill)) {
+        var refundAmount = fill.inputAmount.mul(utils_1.fixedPointAdjustment.sub(lpFeePct)).div(utils_1.fixedPointAdjustment);
+        refundObj.totalRefundAmount = refundObj.totalRefundAmount
+            ? refundObj.totalRefundAmount.add(refundAmount)
+            : refundAmount;
+        (_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])) {
+        (0, utils_1.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])) {
+        (0, utils_1.assign)(dict, [destinationChainId, outputToken], []);
+    }
+    dict[destinationChainId][outputToken].push(deposit);
+}
+var BundleDataClient = (function () {
+    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 = {};
+    }
+    BundleDataClient.prototype.clearCache = function () {
+        this.loadDataCache = {};
+    };
+    BundleDataClient.prototype.loadDataFromCache = function (key) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _b = (_a = lodash_1.default).cloneDeep;
+                        return [4, this.loadDataCache[key]];
+                    case 1: return [2, _b.apply(_a, [_c.sent()])];
+                }
+            });
+        });
+    };
+    BundleDataClient.prototype.getBundleTimestampsFromCache = function (key) {
+        if (this.bundleTimestampCache[key]) {
+            return lodash_1.default.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 tslib_1.__awaiter(this, void 0, void 0, function () {
+            var start, persistedData, convertTypedStringRecordIntoNumericRecord, data, bundleData;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(0, utils_1.isDefined)((_a = this.clients) === null || _a === void 0 ? void 0 : _a.arweaveClient)) {
+                            return [2, undefined];
+                        }
+                        start = performance.now();
+                        return [4, this.clients.arweaveClient.getByTopic(this.getArweaveClientKey(blockRangesForChains), utils_2.BundleDataSS)];
+                    case 1:
+                        persistedData = _b.sent();
+                        if (!(0, utils_1.isDefined)(persistedData) || persistedData.length < 1) {
+                            return [2, 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: (0, utils_2.prettyPrintV3SpokePoolEvents)(bundleData.bundleDepositsV3, bundleData.bundleFillsV3, [], bundleData.bundleSlowFillsV3, bundleData.expiredDepositsToRefundV3, bundleData.unexecutableSlowFills),
+                        });
+                        return [2, bundleData];
+                }
+            });
+        });
+    };
+    BundleDataClient.prototype.getPendingRefundsFromValidBundles = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var refunds, bundle, _a, _b;
+            return tslib_1.__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, 2];
+                        _b = (_a = refunds).push;
+                        return [4, this.getPendingRefundsFromBundle(bundle)];
+                    case 1:
+                        _b.apply(_a, [_c.sent()]);
+                        _c.label = 2;
+                    case 2: return [2, refunds];
+                }
+            });
+        });
+    };
+    BundleDataClient.prototype.getPendingRefundsFromBundle = function (bundle) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var nextBundleMainnetStartBlock, chainIds, bundleEvaluationBlockRanges, combinedRefunds, arweaveData, bundleFillsV3, expiredDepositsToRefundV3;
+            var _this = this;
+            return tslib_1.__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 = (0, utils_1.getImpliedBundleBlockRanges)(this.clients.hubPoolClient, this.clients.configStoreClient, bundle);
+                        return [4, this.loadArweaveData(bundleEvaluationBlockRanges)];
+                    case 1:
+                        arweaveData = _a.sent();
+                        if (arweaveData === undefined) {
+                            combinedRefunds = this.getApproximateRefundsForBlockRange(chainIds, bundleEvaluationBlockRanges);
+                        }
+                        else {
+                            bundleFillsV3 = arweaveData.bundleFillsV3, expiredDepositsToRefundV3 = arweaveData.expiredDepositsToRefundV3;
+                            combinedRefunds = (0, utils_2.getRefundsFromBundle)(bundleFillsV3, expiredDepositsToRefundV3);
+                            Object.keys(combinedRefunds).forEach(function (chainId) {
+                                if (_this.spokePoolClients[Number(chainId)] === undefined) {
+                                    delete combinedRefunds[Number(chainId)];
+                                }
+                            });
+                        }
+                        return [2, this.deductExecutedRefunds(combinedRefunds, bundle)];
+                }
+            });
+        });
+    };
+    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 (_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);
+                (0, utils_1.assert)((0, utils_1.isDefined)(matchingDeposit), "Deposit not found for fill.");
+                var _e = (0, utils_2.getRefundInformationFromFill)(fill, _this.clients.hubPoolClient, blockRanges, _this.chainIdListForBundleEvaluationBlockNumbers, matchingDeposit.fromLiteChain), chainToSendRefundTo = _e.chainToSendRefundTo, repaymentToken = _e.repaymentToken;
+                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 : utils_1.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 (0, utils_1.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);
+        }, (0, utils_1.toBN)(0));
+    };
+    BundleDataClient.prototype.getLatestProposedBundleData = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var hubPoolClient, bundleBlockRanges;
+            var _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        hubPoolClient = this.clients.hubPoolClient;
+                        bundleBlockRanges = (0, utils_1.getImpliedBundleBlockRanges)(hubPoolClient, this.clients.configStoreClient, hubPoolClient.hasPendingProposal()
+                            ? hubPoolClient.getLatestProposedRootBundle()
+                            : hubPoolClient.getLatestFullyExecutedRootBundle(hubPoolClient.latestBlockSearched));
+                        _a = {
+                            blockRanges: bundleBlockRanges
+                        };
+                        return [4, this.loadData(bundleBlockRanges, this.spokePoolClients, true)];
+                    case 1: return [2, (_a.bundleData = _b.sent(),
+                            _a)];
+                }
+            });
+        });
+    };
+    BundleDataClient.prototype.getLatestPoolRebalanceRoot = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, bundleData, blockRanges, hubPoolClient, root;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4, this.getLatestProposedBundleData()];
+                    case 1:
+                        _a = _b.sent(), bundleData = _a.bundleData, blockRanges = _a.blockRanges;
+                        hubPoolClient = this.clients.hubPoolClient;
+                        return [4, (0, utils_2._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, {
+                                root: root,
+                                blockRanges: blockRanges,
+                            }];
+                }
+            });
+        });
+    };
+    BundleDataClient.prototype.getNextBundleRefunds = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            function getBlockRangeDelta(_pendingBlockRanges) {
+                return widestBundleBlockRanges.map(function (blockRange, index) {
+                    var _a;
+                    var initialBlockRange = (_a = _pendingBlockRanges[index]) !== null && _a !== void 0 ? _a : blockRange;
+                    if (initialBlockRange[0] === initialBlockRange[1]) {
+                        return initialBlockRange;
+                    }
+                    if (!(0, utils_1.isDefined)(blockRange[1]) || initialBlockRange[1] >= blockRange[1]) {
+                        return [initialBlockRange[1], initialBlockRange[1]];
+                    }
+                    return [initialBlockRange[1] + 1, blockRange[1]];
+                });
+            }
+            var hubPoolClient, nextBundleMainnetStartBlock, chainIds, combinedRefunds, widestBundleBlockRanges, pendingBundleBlockRanges, arweaveData, bundleFillsV3, expiredDepositsToRefundV3, start;
+            return tslib_1.__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 = (0, utils_2.getWidestPossibleExpectedBlockRange)(chainIds, this.spokePoolClients, (0, utils_2.getEndBlockBuffers)(chainIds, this.blockRangeEndBlockBuffer), this.clients, this.clients.hubPoolClient.latestBlockSearched, this.clients.configStoreClient.getEnabledChains(this.clients.hubPoolClient.latestBlockSearched));
+                        if (!hubPoolClient.hasPendingProposal()) return [3, 2];
+                        pendingBundleBlockRanges = (0, utils_1.getImpliedBundleBlockRanges)(hubPoolClient, this.clients.configStoreClient, hubPoolClient.getLatestProposedRootBundle());
+                        return [4, 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((0, utils_2.getRefundsFromBundle)(bundleFillsV3, expiredDepositsToRefundV3));
+                        }
+                        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, combinedRefunds];
+                }
+            });
+        });
+    };
+    BundleDataClient.prototype.getExecutedRefunds = function (spokePoolClient, relayerRefundRoot) {
+        if (!(0, utils_1.isDefined)(spokePoolClient)) {
+            return {};
+        }
+        var bundle = lodash_1.default.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] = utils_1.bnZero;
+                }
+                executedTokenRefunds[relayer] = executedTokenRefunds[relayer].add(refundAmount);
+            }
+        }
+        return executedRefunds;
+    };
+    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 (!(0, utils_1.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;
+                    }
+                    refunds[relayer] = utils_1.bnZero;
+                }
+            }
+        }
+        return allRefunds;
+    };
+    BundleDataClient.prototype.getRefundsFor = function (bundleRefunds, relayer, chainId, token) {
+        if (!bundleRefunds[chainId] || !bundleRefunds[chainId][token]) {
+            return ethers_1.BigNumber.from(0);
+        }
+        var allRefunds = bundleRefunds[chainId][token];
+        return allRefunds && allRefunds[relayer] ? allRefunds[relayer] : ethers_1.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));
+        }, utils_1.bnZero);
+    };
+    BundleDataClient.prototype.loadArweaveData = function (blockRangesForChains) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var arweaveKey, arweaveData, _a, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        arweaveKey = this.getArweaveClientKey(blockRangesForChains);
+                        if (!this.arweaveDataCache[arweaveKey]) {
+                            this.arweaveDataCache[arweaveKey] = this.loadPersistedDataFromArweave(blockRangesForChains);
+                        }
+                        _b = (_a = lodash_1.default).cloneDeep;
+                        return [4, this.arweaveDataCache[arweaveKey]];
+                    case 1:
+                        arweaveData = _b.apply(_a, [_c.sent()]);
+                        return [2, arweaveData];
+                }
+            });
+        });
+    };
+    BundleDataClient.prototype.loadData = function (blockRangesForChains, spokePoolClients, attemptArweaveLoad) {
+        if (attemptArweaveLoad === void 0) { attemptArweaveLoad = false; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var key, arweaveData, data;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        key = JSON.stringify(blockRangesForChains);
+                        if (!!this.loadDataCache[key]) return [3, 4];
+                        arweaveData = void 0;
+                        if (!attemptArweaveLoad) return [3, 2];
+                        return [4, this.loadArweaveData(blockRangesForChains)];
+                    case 1:
+                        arweaveData = _a.sent();
+                        return [3, 3];
+                    case 2:
+                        arweaveData = undefined;
+                        _a.label = 3;
+                    case 3:
+                        data = (0, utils_1.isDefined)(arweaveData)
+                            ?
+                                Promise.resolve(arweaveData)
+                            : this.loadDataFromScratch(blockRangesForChains, spokePoolClients);
+                        this.loadDataCache[key] = data;
+                        _a.label = 4;
+                    case 4: return [2, this.loadDataFromCache(key)];
+                }
+            });
+        });
+    };
+    BundleDataClient.prototype.loadDataFromScratch = function (blockRangesForChains, spokePoolClients) {
+        return tslib_1.__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 tslib_1.__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 = (0, utils_1.getBlockRangeForChain)(blockRangesForChains, chainId, chainIds);
+                            return (0, utils_2.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, 2];
+                        return [4, 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, 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 = (0, utils_1.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]) {
+                                        return;
+                                    }
+                                    v3RelayHashes[relayDataHash] = {
+                                        deposit: deposit,
+                                        fill: undefined,
+                                        slowFillRequest: undefined,
+                                    };
+                                    if (deposit.blockNumber >= originChainBlockRange[0] && deposit.blockNumber <= originChainBlockRange[1]) {
+                                        updateBundleDepositsV3(bundleDepositsV3, deposit);
+                                        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 tslib_1.__generator(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0:
+                                        originClient = spokePoolClients[originChainId];
+                                        _loop_5 = function (destinationChainId) {
+                                            var destinationClient, destinationChainBlockRange, fastFillsReplacingSlowFills;
+                                            return tslib_1.__generator(this, function (_g) {
+                                                switch (_g.label) {
+                                                    case 0:
+                                                        if (originChainId === destinationChainId) {
+                                                            return [2, "continue"];
+                                                        }
+                                                        destinationClient = spokePoolClients[destinationChainId];
+                                                        destinationChainBlockRange = (0, utils_1.getBlockRangeForChain)(blockRangesForChains, destinationChainId, chainIds);
+                                                        fastFillsReplacingSlowFills = [];
+                                                        return [4, (0, utils_1.forEachAsync)(destinationClient
+                                                                .getFillsForOriginChain(originChainId)
+                                                                .filter(function (fill) { return fill.blockNumber <= destinationChainBlockRange[1]; }), function (fill) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                                                var relayDataHash, historicalDeposit, matchedDeposit;
+                                                                return tslib_1.__generator(this, function (_a) {
+                                                                    switch (_a.label) {
+                                                                        case 0:
+                                                                            relayDataHash = this.getRelayHashFromEvent(fill);
+                                                                            fillCounter++;
+                                                                            if (v3RelayHashes[relayDataHash]) {
+                                                                                if (!v3RelayHashes[relayDataHash].fill) {
+                                                                                    (0, utils_1.assert)((0, utils_1.isDefined)(v3RelayHashes[relayDataHash].deposit), "Deposit should exist in relay hash dictionary.");
+                                                                                    v3RelayHashes[relayDataHash].fill = fill;
+                                                                                    if (fill.blockNumber >= destinationChainBlockRange[0]) {
+                                                                                        validatedBundleV3Fills.push(tslib_1.__assign(tslib_1.__assign({}, fill), { quoteTimestamp: v3RelayHashes[relayDataHash].deposit.quoteTimestamp }));
+                                                                                        if (fill.relayExecutionInfo.fillType === interfaces_1.FillType.ReplacedSlowFill) {
+                                                                                            fastFillsReplacingSlowFills.push(relayDataHash);
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                return [2];
+                                                                            }
+                                                                            v3RelayHashes[relayDataHash] = {
+                                                                                deposit: undefined,
+                                                                                fill: fill,
+                                                                                slowFillRequest: undefined,
+                                                                            };
+                                                                            if (!(fill.blockNumber >= destinationChainBlockRange[0])) return [3, 2];
+                                                                            if (!exports.INFINITE_FILL_DEADLINE.eq(fill.fillDeadline)) {
+                                                                                bundleInvalidFillsV3.push(fill);
+                                                                                return [2];
+                                                                            }
+                                                                            return [4, (0, utils_1.queryHistoricalDepositForFill)(originClient, fill)];
+                                                                        case 1:
+                                                                            historicalDeposit = _a.sent();
+                                                                            if (!historicalDeposit.found) {
+                                                                                bundleInvalidFillsV3.push(fill);
+                                                                            }
+                                                                            else {
+                                                                                matchedDeposit = historicalDeposit.deposit;
+                                                                                (0, utils_1.assert)(this.getRelayHashFromEvent(matchedDeposit) === relayDataHash, "Relay hashes should match.");
+                                                                                validatedBundleV3Fills.push(tslib_1.__assign(tslib_1.__assign({}, fill), { quoteTimestamp: matchedDeposit.quoteTimestamp }));
+                                                                                v3RelayHashes[relayDataHash].deposit = matchedDeposit;
+                                                                                if (fill.relayExecutionInfo.fillType === interfaces_1.FillType.ReplacedSlowFill) {
+                                                                                    fastFillsReplacingSlowFills.push(relayDataHash);
+                                                                                }
+                                                                            }
+                                                                            _a.label = 2;
+                                                                        case 2: return [2];
+                                                                    }
+                                                                });
+                                                            }); })];
+                                                    case 1:
+                                                        _g.sent();
+                                                        return [4, (0, utils_1.forEachAsync)(destinationClient
+                                                                .getSlowFillRequestsForOriginChain(originChainId)
+                                                                .filter(function (request) { return request.blockNumber <= destinationChainBlockRange[1]; }), function (slowFillRequest) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                                                var relayDataHash, matchedDeposit, historicalDeposit, matchedDeposit;
+                                                                var _a, _b;
+                                                                return tslib_1.__generator(this, function (_c) {
+                                                                    switch (_c.label) {
+                                                                        case 0:
+                                                                            relayDataHash = this.getRelayHashFromEvent(slowFillRequest);
+                                                                            if (v3RelayHashes[relayDataHash]) {
+                                                                                if (!v3RelayHashes[relayDataHash].slowFillRequest) {
+                                                                                    v3RelayHashes[relayDataHash].slowFillRequest = slowFillRequest;
+                                                                                    if (v3RelayHashes[relayDataHash].fill) {
+                                                                                        return [2];
+                                                                                    }
+                                                                                    (0, utils_1.assert)((0, utils_1.isDefined)(v3RelayHashes[relayDataHash].deposit), "Deposit should exist in relay hash dictionary.");
+                                                                                    matchedDeposit = v3RelayHashes[relayDataHash].deposit;
+                                                                                    if (!this.clients.hubPoolClient.areTokensEquivalent(matchedDeposit.inputToken, matchedDeposit.originChainId, matchedDeposit.outputToken, matchedDeposit.destinationChainId, matchedDeposit.quoteBlockNumber)) {
+                                                                                        return [2];
+                                                                                    }
+                                                                                    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];
+                                                                                    }
+                                                                                    if (slowFillRequest.blockNumber >= destinationChainBlockRange[0] &&
+                                                                                        slowFillRequest.fillDeadline >= bundleBlockTimestamps[destinationChainId][1]) {
+                                                                                        validatedBundleSlowFills.push(matchedDeposit);
+                                                                                    }
+                                                                                }
+                                                                                return [2];
+                                                                            }
+                                                                            v3RelayHashes[relayDataHash] = {
+                                                                                deposit: undefined,
+                                                                                fill: undefined,
+                                                                                slowFillRequest: slowFillRequest,
+                                                                            };
+                                                                            if (!(exports.INFINITE_FILL_DEADLINE.eq(slowFillRequest.fillDeadline) &&
+                                                                                slowFillRequest.blockNumber >= destinationChainBlockRange[0])) return [3, 2];
+                                                                            return [4, (0, utils_1.queryHistoricalDepositForFill)(originClient, slowFillRequest)];
+                                                                        case 1:
+                                                                            historicalDeposit = _c.sent();
+                                                                            if (!historicalDeposit.found) {
+                                                                                return [2];
+                                                                            }
+                                                                            matchedDeposit = historicalDeposit.deposit;
+                                                                            (0, utils_1.assert)(this.getRelayHashFromEvent(matchedDeposit) === relayDataHash, "Deposit relay hashes should match.");
+                                                                            if (matchedDeposit.fromLiteChain || matchedDeposit.toLiteChain) {
+                                                                                return [2];
+                                                                            }
+                                                                            v3RelayHashes[relayDataHash].deposit = matchedDeposit;
+                                                                            if (!this.clients.hubPoolClient.areTokensEquivalent(matchedDeposit.inputToken, matchedDeposit.originChainId, matchedDeposit.outputToken, matchedDeposit.destinationChainId, matchedDeposit.quoteBlockNumber) ||
+                                                                                slowFillRequest.fillDeadline < bundleBlockTimestamps[destinationChainId][1]) {
+                                                                                return [2];
+                                                                            }
+                                                                            validatedBundleSlowFills.push(matchedDeposit);
+                                                                            _c.label = 2;
+                                                                        case 2: return [2];
+                                                                    }
+                                                                });
+                                                            }); })];
+                                                    case 2:
+                                                        _g.sent();
+                                                        fastFillsReplacingSlowFills.forEach(function (relayDataHash) {
+                                                            var _a = v3RelayHashes[relayDataHash], deposit = _a.deposit, slowFillRequest = _a.slowFillRequest, fill = _a.fill;
+                                                            (0, utils_1.assert)((fill === null || fill === void 0 ? void 0 : fill.relayExecutionInfo.fillType) === interfaces_1.FillType.ReplacedSlowFill, "Fill type should be ReplacedSlowFill.");
+                                                            if (!deposit) {
+                                                                throw new Error("Deposit should exist in relay hash dictionary.");
+                                                            }
+                                                            var destinationBlockRange = (0, utils_1.getBlockRangeForChain)(blockRangesForChains, destinationChainId, chainIds);
+                                                            if (_this.clients.hubPoolClient.areTokensEquivalent(deposit.inputToken, deposit.originChainId, deposit.outputToken, deposit.destinationChainId, deposit.quoteBlockNumber) &&
+                                                                (!slowFillRequest || slowFillRequest.blockNumber < destinationBlockRange[0])) {
+                                                                validatedBundleUnexecutableSlowFills.push(deposit);
+                                                            }
+                                                        });
+                                                        return [2];
+                                                }
+                                            });
+                                        };
+                                        _e = 0, allChainIds_4 = allChainIds;
+                                        _f.label = 1;
+                                    case 1:
+                                        if (!(_e < allChainIds_4.length)) return [3, 4];
+                                        destinationChainId = allChainIds_4[_e];
+                                        return [5, _loop_5(destinationChainId)];
+                                    case 2:
+                                        _f.sent();
+                                        _f.label = 3;
+                                    case 3:
+                                        _e++;
+                                        return [3, 1];
+                                    case 4: return [2];
+                                }
+                            });
+                        };
+                        _a = 0, allChainIds_2 = allChainIds;
+                        _c.label = 4;
+                    case 4:
+                        if (!(_a < allChainIds_2.length)) return [3, 7];
+                        originChainId = allChainIds_2[_a];
+                        return [5, _loop_3(originChainId)];
+                    case 5:
+                        _c.sent();
+                        _c.label = 6;
+                    case 6:
+                        _a++;
+                        return [3, 4];
+                    case 7:
+                        this.logger.debug({
+                            at: "BundleDataClient#loadData",
+                            message: "Processed ".concat(fillCounter, " fills in ").concat(performance.now() - start, "ms."),
+                        });
+                        start = performance.now();
+                        expiredBundleDepositHashes.forEach(function (relayDataHash) {
+                            var _a = v3RelayHashes[relayDataHash], deposit = _a.deposit, fill = _a.fill;
+                            (0, utils_1.assert)((0, utils_1.isDefined)(deposit), "Deposit should exist in relay hash dictionary.");
+                            if (!fill &&
+                                (0, utils_1.isDefined)(deposit)) {
+                                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
+                            }
+                        });
+                        return [4, (0, utils_1.forEachAsync)(Array.from(olderDepositHashes), function (relayDataHash) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var _a, deposit, slowFillRequest, fill, destinationChainId, destinationBlockRange, fillStatus;
+                                return tslib_1.__generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            _a = v3RelayHashes[relayDataHash], deposit = _a.deposit, slowFillRequest = _a.slowFillRequest, fill = _a.fill;
+                                            (0, utils_1.assert)((0, utils_1.isDefined)(deposit), "Deposit should exist in relay hash dictionary.");
+                                            destinationChainId = deposit.destinationChainId;
+                                            destinationBlockRange = (0, utils_1.getBlockRangeForChain)(blockRangesForChains, destinationChainId, chainIds);
+                                            if (!(!fill &&
+                                                (0, utils_1.isDefined)(deposit) &&
+                                                deposit.fillDeadline < bundleBlockTimestamps[destinationChainId][1] &&
+                                                deposit.fillDeadline >= bundleBlockTimestamps[destinationChainId][0] &&
+                                                spokePoolClients[destinationChainId] !== undefined)) return [3, 2];
+                                            return [4, (0, utils_1.relayFillStatus)(spokePoolClients[destinationChainId].spokePool, deposit, Math.min(destinationBlockRange[1], spokePoolClients[destinationChainId].latestBlockSearched), destinationChainId)];
+                                        case 1:
+                                            fillStatus = _b.sent();
+                                            if (fillStatus !== interfaces_1.FillStatus.Filled) {
+                                                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
+                                            }
+                                            if (fillStatus !== interfaces_1.FillStatus.RequestedSlowFill) {
+                                                return [2];
+                                            }
+                                            if (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];
+                                    }
+                                });
+                            }); })];
+                    case 8:
+                        _c.sent();
+                        start = performance.now();
+                        promises = [
+                            validatedBundleV3Fills.length > 0
+                                ? this.clients.hubPoolClient.batchComputeRealizedLpFeePct(validatedBundleV3Fills.map(function (fill) {
+                                    var matchedDeposit = v3RelayHashes[_this.getRelayHashFromEvent(fill)].deposit;
+                                    (0, utils_1.assert)((0, utils_1.isDefined)(matchedDeposit), "Deposit should exist in relay hash dictionary.");
+                                    var paymentChainId = (0, utils_2.getRefundInformationFromFill)(fill, _this.clients.hubPoolClient, blockRangesForChains, chainIds, matchedDeposit.fromLiteChain).chainToSendRefundTo;
+                                    return tslib_1.__assign(tslib_1.__assign({}, fill), { paymentChainId: paymentChainId });
+                                }))
+                                : [],
+                            validatedBundleSlowFills.length > 0
+                                ? this.clients.hubPoolClient.batchComputeRealizedLpFeePct(validatedBundleSlowFills.map(function (deposit) {
+                                    return tslib_1.__assign(tslib_1.__assign({}, deposit), { paymentChainId: deposit.destinationChainId });
+                                }))
+                                : [],
+                            validatedBundleUnexecutableSlowFills.length > 0
+                                ? this.clients.hubPoolClient.batchComputeRealizedLpFeePct(validatedBundleUnexecutableSlowFills.map(function (deposit) {
+                                    return tslib_1.__assign(tslib_1.__assign({}, deposit), { paymentChainId: deposit.destinationChainId });
+                                }))
+                                : [],
+                        ];
+                        return [4, 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;
+                            (0, utils_1.assert)((0, utils_1.isDefined)(associatedDeposit), "Deposit should exist in relay hash dictionary.");
+                            var _b = (0, utils_2.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, tslib_1.__assign(tslib_1.__assign({}, deposit), { lpFeePct: lpFeePct }));
+                        });
+                        v3UnexecutableSlowFillLpFees.forEach(function (_a, idx) {
+                            var lpFeePct = _a.realizedLpFeePct;
+                            var deposit = validatedBundleUnexecutableSlowFills[idx];
+                            updateBundleExcessSlowFills(unexecutableSlowFills, tslib_1.__assign(tslib_1.__assign({}, deposit), { lpFeePct: lpFeePct }));
+                        });
+                        v3SpokeEventsReadable = (0, utils_2.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, {
+                                bundleDepositsV3: bundleDepositsV3,
+                                expiredDepositsToRefundV3: expiredDepositsToRefundV3,
+                                bundleFillsV3: bundleFillsV3,
+                                unexecutableSlowFills: unexecutableSlowFills,
+                                bundleSlowFillsV3: bundleSlowFillsV3,
+                            }];
+                }
+            });
+        });
+    };
+    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 tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            var _this = this;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _b = (_a = Object).fromEntries;
+                        return [4, (0, utils_1.mapAsync)(chainIds, function (chainId, index) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var blockRangeForChain, _startBlockForChain, _endBlockForChain, spokePoolClient, startBlockForChain, endBlockForChain, _a, startTime, endTime, _b, _c, _d;
+                                return tslib_1.__generator(this, function (_e) {
+                                    switch (_e.label) {
+                                        case 0:
+                                            blockRangeForChain = blockRangesForChains[index];
+                                            if (!(0, utils_1.isDefined)(blockRangeForChain) || (0, utils_2.isChainDisabled)(blockRangeForChain)) {
+                                                return [2];
+                                            }
+                                            _startBlockForChain = blockRangeForChain[0], _endBlockForChain = blockRangeForChain[1];
+                                            spokePoolClient = spokePoolClients[chainId];
+                                            if (!(0, utils_1.isDefined)(spokePoolClient)) {
+                                                return [2];
+                                            }
+                                            startBlockForChain = Math.min(_startBlockForChain, spokePoolClient.latestBlockSearched);
+                                            endBlockForChain = Math.min(_endBlockForChain, spokePoolClient.latestBlockSearched);
+                                            _b = Number;
+                                            return [4, spokePoolClient.spokePool.provider.getBlock(startBlockForChain)];
+                                        case 1:
+                                            _c = [
+                                                _b.apply(void 0, [(_e.sent()).timestamp])
+                                            ];
+                                            _d = Number;
+                                            return [4, spokePoolClient.spokePool.provider.getBlock(endBlockForChain)];
+                                        case 2:
+                                            _a = _c.concat([
+                                                _d.apply(void 0, [(_e.sent()).timestamp])
+                                            ]), startTime = _a[0], endTime = _a[1];
+                                            (0, utils_1.assert)(endTime >= startTime, "End time should be greater than start time.");
+                                            (0, utils_1.assert)(startTime > 0, "Start time should be greater than 0.");
+                                            return [2, [chainId, [startTime, endTime]]];
+                                    }
+                                });
+                            }); })];
+                    case 1: return [2, _b.apply(_a, [(_c.sent()).filter(utils_1.isDefined)])];
+                }
+            });
+        });
+    };
+    return BundleDataClient;
+}());
+exports.BundleDataClient = BundleDataClient;
+//# sourceMappingURL=BundleDataClient.js.map