@ichidao/ichi-vaults-sdk 0.1.43 → 2.0.1

package/dist/src/functions/_vaultEvents.js

@@ -1,519 +1,378 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVaultStateAt = exports._getAllVaultEvents = exports._getWithdraws = exports._getDeposits = exports._getFeesCollectedEvents = exports._getRebalances = exports._getAllEvents = void 0;
 // eslint-disable import/no-cycle
-var constants_1 = require("../graphql/constants");
-var queries_1 = require("../graphql/queries");
-var timestamps_1 = require("../utils/timestamps");
-var getGraphUrls_1 = require("../utils/getGraphUrls");
-var cache_1 = __importDefault(require("../utils/cache"));
-var functions_1 = require("../graphql/functions");
-function _getAllEvents(vaultAddress, chainId, dex, days) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function () {
-        var key, cachedData, ttl, _b, publishedUrl, url, currTimestamp, startTimestamp, supportsCollectFees, query, allEvents, endOfData, lastTimestamps, hasMoreData, result, error_1, error2_1;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    key = "allevents-".concat(chainId, "-").concat(vaultAddress, "-").concat(days);
-                    cachedData = cache_1.default.get(key);
-                    if (cachedData) {
-                        return [2 /*return*/, cachedData];
-                    }
-                    ttl = 120000;
-                    _b = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true), publishedUrl = _b.publishedUrl, url = _b.url;
-                    currTimestamp = Date.now();
-                    startTimestamp = days
-                        ? parseInt(((currTimestamp - (0, timestamps_1.daysToMilliseconds)(days)) / 1000).toString()).toString()
-                        : '0';
-                    supportsCollectFees = (_a = constants_1.graphUrls[chainId][dex]) === null || _a === void 0 ? void 0 : _a.supportsCollectFees;
-                    query = supportsCollectFees ? queries_1.allEventsQuery : queries_1.allEventsNoCollectFeesQuery;
-                    allEvents = [];
-                    endOfData = false;
-                    lastTimestamps = {
-                        rebalances: startTimestamp,
-                        collectFees: startTimestamp,
-                        deposits: startTimestamp,
-                        withdraws: startTimestamp,
-                    };
-                    hasMoreData = {
-                        rebalances: true,
-                        collectFees: supportsCollectFees,
-                        deposits: true,
-                        withdraws: true,
-                    };
-                    _c.label = 1;
-                case 1:
-                    if (!!endOfData) return [3 /*break*/, 12];
-                    result = void 0;
-                    _c.label = 2;
-                case 2:
-                    _c.trys.push([2, 6, , 11]);
-                    if (!publishedUrl) return [3 /*break*/, 4];
-                    return [4 /*yield*/, (0, functions_1.sendAllEventsQueryRequest)(publishedUrl, vaultAddress, startTimestamp, query(lastTimestamps))];
-                case 3:
-                    result = _c.sent();
-                    return [3 /*break*/, 5];
-                case 4: throw new Error("Published URL is invalid for dex ".concat(dex, " on chain ").concat(chainId));
-                case 5: return [3 /*break*/, 11];
-                case 6:
-                    error_1 = _c.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_1);
-                    }
-                    _c.label = 7;
-                case 7:
-                    _c.trys.push([7, 9, , 10]);
-                    return [4 /*yield*/, (0, functions_1.sendAllEventsQueryRequest)(url, vaultAddress, startTimestamp, query(lastTimestamps))];
-                case 8:
-                    result = _c.sent();
-                    return [3 /*break*/, 10];
-                case 9:
-                    error2_1 = _c.sent();
-                    console.error('Request to public graph URL failed:', error2_1);
-                    throw new Error("Could not get events for vault ".concat(vaultAddress, " on chain ").concat(chainId));
-                case 10: return [3 /*break*/, 11];
-                case 11:
-                    if (result) {
-                        // Add the results to our collection
-                        if (result.vaultRebalances && result.vaultRebalances.length > 0) {
-                            allEvents.push.apply(allEvents, result.vaultRebalances);
-                            // Update cursor for next query
-                            lastTimestamps.rebalances = result.vaultRebalances[result.vaultRebalances.length - 1].createdAtTimestamp;
-                            // Check if we've reached the end for this entity
-                            if (result.vaultRebalances.length < 1000) {
-                                hasMoreData.rebalances = false;
-                            }
-                        }
-                        else {
-                            hasMoreData.rebalances = false;
-                        }
-                        if (supportsCollectFees && result.vaultCollectFees && result.vaultCollectFees.length > 0) {
-                            allEvents.push.apply(allEvents, result.vaultCollectFees);
-                            // Update cursor for next query
-                            lastTimestamps.collectFees = result.vaultCollectFees[result.vaultCollectFees.length - 1].createdAtTimestamp;
-                            // Check if we've reached the end for this entity
-                            if (result.vaultCollectFees.length < 1000) {
-                                hasMoreData.collectFees = false;
-                            }
-                        }
-                        else {
-                            hasMoreData.collectFees = false;
-                        }
-                        if (result.vaultDeposits && result.vaultDeposits.length > 0) {
-                            allEvents.push.apply(allEvents, result.vaultDeposits);
-                            // Update cursor for next query
-                            lastTimestamps.deposits = result.vaultDeposits[result.vaultDeposits.length - 1].createdAtTimestamp;
-                            // Check if we've reached the end for this entity
-                            if (result.vaultDeposits.length < 1000) {
-                                hasMoreData.deposits = false;
-                            }
-                        }
-                        else {
-                            hasMoreData.deposits = false;
-                        }
-                        if (result.vaultWithdraws && result.vaultWithdraws.length > 0) {
-                            allEvents.push.apply(allEvents, result.vaultWithdraws);
-                            // Update cursor for next query
-                            lastTimestamps.withdraws = result.vaultWithdraws[result.vaultWithdraws.length - 1].createdAtTimestamp;
-                            // Check if we've reached the end for this entity
-                            if (result.vaultWithdraws.length < 1000) {
-                                hasMoreData.withdraws = false;
-                            }
-                        }
-                        else {
-                            hasMoreData.withdraws = false;
-                        }
-                        // Check if we've reached the end for all entity types
-                        endOfData = !Object.values(hasMoreData).some(function (hasMore) { return hasMore; });
-                    }
-                    else {
-                        endOfData = true;
-                    }
-                    return [3 /*break*/, 1];
-                case 12:
-                    cache_1.default.set(key, allEvents, ttl);
-                    return [2 /*return*/, allEvents];
-            }
-        });
-    });
+const constants_1 = require("../graphql/constants");
+const queries_1 = require("../graphql/queries");
+const timestamps_1 = require("../utils/timestamps");
+const getGraphUrls_1 = require("../utils/getGraphUrls");
+const cache_1 = __importDefault(require("../utils/cache"));
+const functions_1 = require("../graphql/functions");
+async function _getAllEvents(vaultAddress, chainId, dex, days) {
+    const key = `allevents-${chainId}-${vaultAddress}-${days}`;
+    const cachedData = cache_1.default.get(key);
+    if (cachedData) {
+        return cachedData;
+    }
+    const ttl = 120000;
+    const { publishedUrl, url } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true);
+    const currTimestamp = Date.now();
+    const startTimestamp = days
+        ? parseInt(((currTimestamp - (0, timestamps_1.daysToMilliseconds)(days)) / 1000).toString()).toString()
+        : '0';
+    const supportsCollectFees = constants_1.graphUrls[chainId][dex]?.supportsCollectFees;
+    const query = supportsCollectFees ? queries_1.allEventsQuery : queries_1.allEventsNoCollectFeesQuery;
+    const allEvents = [];
+    let endOfData = false;
+    // Track last timestamp for each entity type
+    const lastTimestamps = {
+        rebalances: startTimestamp,
+        collectFees: startTimestamp,
+        deposits: startTimestamp,
+        withdraws: startTimestamp,
+    };
+    // Track whether each entity type has more data
+    const hasMoreData = {
+        rebalances: true,
+        collectFees: supportsCollectFees,
+        deposits: true,
+        withdraws: true,
+    };
+    while (!endOfData) {
+        let result;
+        try {
+            if (publishedUrl) {
+                result = await (0, functions_1.sendAllEventsQueryRequest)(publishedUrl, vaultAddress, startTimestamp, query(lastTimestamps));
+            }
+            else {
+                throw new Error(`Published URL is invalid for dex ${dex} on chain ${chainId}`);
+            }
+        }
+        catch (error) {
+            if (publishedUrl) {
+                console.error('Request to published graph URL failed:', error);
+            }
+            try {
+                result = await (0, functions_1.sendAllEventsQueryRequest)(url, vaultAddress, startTimestamp, query(lastTimestamps));
+            }
+            catch (error2) {
+                console.error('Request to public graph URL failed:', error2);
+                throw new Error(`Could not get events for vault ${vaultAddress} on chain ${chainId}`);
+            }
+        }
+        if (result) {
+            // Add the results to our collection
+            if (result.vaultRebalances && result.vaultRebalances.length > 0) {
+                allEvents.push(...result.vaultRebalances);
+                // Update cursor for next query
+                lastTimestamps.rebalances = result.vaultRebalances[result.vaultRebalances.length - 1].createdAtTimestamp;
+                // Check if we've reached the end for this entity
+                if (result.vaultRebalances.length < 1000) {
+                    hasMoreData.rebalances = false;
+                }
+            }
+            else {
+                hasMoreData.rebalances = false;
+            }
+            if (supportsCollectFees && result.vaultCollectFees && result.vaultCollectFees.length > 0) {
+                allEvents.push(...result.vaultCollectFees);
+                // Update cursor for next query
+                lastTimestamps.collectFees = result.vaultCollectFees[result.vaultCollectFees.length - 1].createdAtTimestamp;
+                // Check if we've reached the end for this entity
+                if (result.vaultCollectFees.length < 1000) {
+                    hasMoreData.collectFees = false;
+                }
+            }
+            else {
+                hasMoreData.collectFees = false;
+            }
+            if (result.vaultDeposits && result.vaultDeposits.length > 0) {
+                allEvents.push(...result.vaultDeposits);
+                // Update cursor for next query
+                lastTimestamps.deposits = result.vaultDeposits[result.vaultDeposits.length - 1].createdAtTimestamp;
+                // Check if we've reached the end for this entity
+                if (result.vaultDeposits.length < 1000) {
+                    hasMoreData.deposits = false;
+                }
+            }
+            else {
+                hasMoreData.deposits = false;
+            }
+            if (result.vaultWithdraws && result.vaultWithdraws.length > 0) {
+                allEvents.push(...result.vaultWithdraws);
+                // Update cursor for next query
+                lastTimestamps.withdraws = result.vaultWithdraws[result.vaultWithdraws.length - 1].createdAtTimestamp;
+                // Check if we've reached the end for this entity
+                if (result.vaultWithdraws.length < 1000) {
+                    hasMoreData.withdraws = false;
+                }
+            }
+            else {
+                hasMoreData.withdraws = false;
+            }
+            // Check if we've reached the end for all entity types
+            endOfData = !Object.values(hasMoreData).some((hasMore) => hasMore);
+        }
+        else {
+            endOfData = true;
+        }
+    }
+    cache_1.default.set(key, allEvents, ttl);
+    return allEvents;
 }
 exports._getAllEvents = _getAllEvents;
 // eslint-disable-next-line no-underscore-dangle
-function _getRebalances(vaultAddress, chainId, dex, days) {
-    return __awaiter(this, void 0, void 0, function () {
-        var key, cachedData, ttl, _a, publishedUrl, url, currTimestamp, startTimestamp, rebalances, endOfData, lastTimestamp, result, error_2, error2_2;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    key = "rebalances-".concat(chainId, "-").concat(vaultAddress, "-").concat(days);
-                    cachedData = cache_1.default.get(key);
-                    if (cachedData) {
-                        return [2 /*return*/, cachedData];
-                    }
-                    ttl = 120000;
-                    _a = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true), publishedUrl = _a.publishedUrl, url = _a.url;
-                    currTimestamp = Date.now();
-                    startTimestamp = days
-                        ? parseInt(((currTimestamp - (0, timestamps_1.daysToMilliseconds)(days)) / 1000).toString()).toString()
-                        : '0';
-                    rebalances = [];
-                    endOfData = false;
-                    lastTimestamp = startTimestamp;
-                    _b.label = 1;
-                case 1:
-                    if (!!endOfData) return [3 /*break*/, 12];
-                    result = void 0;
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 6, , 11]);
-                    if (!publishedUrl) return [3 /*break*/, 4];
-                    return [4 /*yield*/, (0, functions_1.sendRebalancesQueryRequest)(publishedUrl, vaultAddress, startTimestamp, (0, queries_1.rebalancesQuery)(lastTimestamp))];
-                case 3:
-                    result = _b.sent();
-                    return [3 /*break*/, 5];
-                case 4: throw new Error("Published URL is invalid for dex ".concat(dex, " on chain ").concat(chainId));
-                case 5: return [3 /*break*/, 11];
-                case 6:
-                    error_2 = _b.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_2);
-                    }
-                    _b.label = 7;
-                case 7:
-                    _b.trys.push([7, 9, , 10]);
-                    return [4 /*yield*/, (0, functions_1.sendRebalancesQueryRequest)(url, vaultAddress, startTimestamp, (0, queries_1.rebalancesQuery)(lastTimestamp))];
-                case 8:
-                    result = _b.sent();
-                    return [3 /*break*/, 10];
-                case 9:
-                    error2_2 = _b.sent();
-                    console.error('Request to public graph URL failed:', error2_2);
-                    throw new Error("Could not get rebalances for vault ".concat(vaultAddress, " on chain ").concat(chainId));
-                case 10: return [3 /*break*/, 11];
-                case 11:
-                    if (result && result.length > 0) {
-                        rebalances.push.apply(rebalances, result);
-                        if (result.length < 1000) {
-                            endOfData = true;
-                        }
-                        else {
-                            // Update the cursor to the timestamp of the last item
-                            lastTimestamp = result[result.length - 1].createdAtTimestamp;
-                        }
-                    }
-                    else {
-                        endOfData = true;
-                    }
-                    return [3 /*break*/, 1];
-                case 12:
-                    cache_1.default.set(key, rebalances, ttl);
-                    return [2 /*return*/, rebalances];
-            }
-        });
-    });
+async function _getRebalances(vaultAddress, chainId, dex, days) {
+    const key = `rebalances-${chainId}-${vaultAddress}-${days}`;
+    const cachedData = cache_1.default.get(key);
+    if (cachedData) {
+        return cachedData;
+    }
+    const ttl = 120000;
+    const { publishedUrl, url } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true);
+    const currTimestamp = Date.now();
+    const startTimestamp = days
+        ? parseInt(((currTimestamp - (0, timestamps_1.daysToMilliseconds)(days)) / 1000).toString()).toString()
+        : '0';
+    const rebalances = [];
+    let endOfData = false;
+    let lastTimestamp = startTimestamp;
+    while (!endOfData) {
+        let result;
+        try {
+            if (publishedUrl) {
+                result = await (0, functions_1.sendRebalancesQueryRequest)(publishedUrl, vaultAddress, startTimestamp, (0, queries_1.rebalancesQuery)(lastTimestamp));
+            }
+            else {
+                throw new Error(`Published URL is invalid for dex ${dex} on chain ${chainId}`);
+            }
+        }
+        catch (error) {
+            if (publishedUrl) {
+                console.error('Request to published graph URL failed:', error);
+            }
+            try {
+                result = await (0, functions_1.sendRebalancesQueryRequest)(url, vaultAddress, startTimestamp, (0, queries_1.rebalancesQuery)(lastTimestamp));
+            }
+            catch (error2) {
+                console.error('Request to public graph URL failed:', error2);
+                throw new Error(`Could not get rebalances for vault ${vaultAddress} on chain ${chainId}`);
+            }
+        }
+        if (result && result.length > 0) {
+            rebalances.push(...result);
+            if (result.length < 1000) {
+                endOfData = true;
+            }
+            else {
+                // Update the cursor to the timestamp of the last item
+                lastTimestamp = result[result.length - 1].createdAtTimestamp;
+            }
+        }
+        else {
+            endOfData = true;
+        }
+    }
+    cache_1.default.set(key, rebalances, ttl);
+    return rebalances;
 }
 exports._getRebalances = _getRebalances;
 // eslint-disable-next-line no-underscore-dangle
-function _getFeesCollectedEvents(vaultAddress, chainId, dex, days) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function () {
-        var key, cachedData, ttl, _b, publishedUrl, url, supportsCollectFees, result, currTimestamp, startTimestamp, otherFees, endOfData, lastTimestamp, result, error_3, error2_3;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    key = "fees-".concat(chainId, "-").concat(vaultAddress, "-").concat(days);
-                    cachedData = cache_1.default.get(key);
-                    if (cachedData) {
-                        return [2 /*return*/, cachedData];
-                    }
-                    ttl = 120000;
-                    _b = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true), publishedUrl = _b.publishedUrl, url = _b.url;
-                    supportsCollectFees = (_a = constants_1.graphUrls[chainId][dex]) === null || _a === void 0 ? void 0 : _a.supportsCollectFees;
-                    if (!supportsCollectFees) {
-                        result = [];
-                        cache_1.default.set(key, result, 24 * 60 * 60 * 1000);
-                        return [2 /*return*/, result];
-                    }
-                    currTimestamp = Date.now();
-                    startTimestamp = days
-                        ? parseInt(((currTimestamp - (0, timestamps_1.daysToMilliseconds)(days)) / 1000).toString()).toString()
-                        : '0';
-                    otherFees = [];
-                    endOfData = false;
-                    lastTimestamp = startTimestamp;
-                    _c.label = 1;
-                case 1:
-                    if (!!endOfData) return [3 /*break*/, 12];
-                    result = void 0;
-                    _c.label = 2;
-                case 2:
-                    _c.trys.push([2, 6, , 11]);
-                    if (!publishedUrl) return [3 /*break*/, 4];
-                    return [4 /*yield*/, (0, functions_1.sendCollectFeesQueryRequest)(publishedUrl, vaultAddress, startTimestamp, (0, queries_1.vaultCollectFeesQuery)(lastTimestamp))];
-                case 3:
-                    result = _c.sent();
-                    return [3 /*break*/, 5];
-                case 4: throw new Error("Published URL is invalid for dex ".concat(dex, " on chain ").concat(chainId));
-                case 5: return [3 /*break*/, 11];
-                case 6:
-                    error_3 = _c.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_3);
-                    }
-                    _c.label = 7;
-                case 7:
-                    _c.trys.push([7, 9, , 10]);
-                    return [4 /*yield*/, (0, functions_1.sendCollectFeesQueryRequest)(url, vaultAddress, startTimestamp, (0, queries_1.vaultCollectFeesQuery)(lastTimestamp))];
-                case 8:
-                    result = _c.sent();
-                    return [3 /*break*/, 10];
-                case 9:
-                    error2_3 = _c.sent();
-                    console.error('Request to public graph URL failed:', error2_3);
-                    throw new Error("Could not get collected fees for vault ".concat(vaultAddress, " on chain ").concat(chainId));
-                case 10: return [3 /*break*/, 11];
-                case 11:
-                    if (result && result.length > 0) {
-                        otherFees.push.apply(otherFees, result);
-                        if (result.length < 1000) {
-                            endOfData = true;
-                        }
-                        else {
-                            // Update the cursor to the timestamp of the last item
-                            lastTimestamp = result[result.length - 1].createdAtTimestamp;
-                        }
-                    }
-                    else {
-                        endOfData = true;
-                    }
-                    return [3 /*break*/, 1];
-                case 12:
-                    cache_1.default.set(key, otherFees, ttl);
-                    return [2 /*return*/, otherFees];
-            }
-        });
-    });
+async function _getFeesCollectedEvents(vaultAddress, chainId, dex, days) {
+    const key = `fees-${chainId}-${vaultAddress}-${days}`;
+    const cachedData = cache_1.default.get(key);
+    if (cachedData) {
+        return cachedData;
+    }
+    const ttl = 120000;
+    const { publishedUrl, url } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true);
+    const supportsCollectFees = constants_1.graphUrls[chainId][dex]?.supportsCollectFees;
+    if (!supportsCollectFees) {
+        const result = [];
+        cache_1.default.set(key, result, 24 * 60 * 60 * 1000);
+        return result;
+    }
+    const currTimestamp = Date.now();
+    const startTimestamp = days
+        ? parseInt(((currTimestamp - (0, timestamps_1.daysToMilliseconds)(days)) / 1000).toString()).toString()
+        : '0';
+    const otherFees = [];
+    let endOfData = false;
+    let lastTimestamp = startTimestamp;
+    while (!endOfData) {
+        let result;
+        try {
+            if (publishedUrl) {
+                result = await (0, functions_1.sendCollectFeesQueryRequest)(publishedUrl, vaultAddress, startTimestamp, (0, queries_1.vaultCollectFeesQuery)(lastTimestamp));
+            }
+            else {
+                throw new Error(`Published URL is invalid for dex ${dex} on chain ${chainId}`);
+            }
+        }
+        catch (error) {
+            if (publishedUrl) {
+                console.error('Request to published graph URL failed:', error);
+            }
+            try {
+                result = await (0, functions_1.sendCollectFeesQueryRequest)(url, vaultAddress, startTimestamp, (0, queries_1.vaultCollectFeesQuery)(lastTimestamp));
+            }
+            catch (error2) {
+                console.error('Request to public graph URL failed:', error2);
+                throw new Error(`Could not get collected fees for vault ${vaultAddress} on chain ${chainId}`);
+            }
+        }
+        if (result && result.length > 0) {
+            otherFees.push(...result);
+            if (result.length < 1000) {
+                endOfData = true;
+            }
+            else {
+                // Update the cursor to the timestamp of the last item
+                lastTimestamp = result[result.length - 1].createdAtTimestamp;
+            }
+        }
+        else {
+            endOfData = true;
+        }
+    }
+    cache_1.default.set(key, otherFees, ttl);
+    return otherFees;
 }
 exports._getFeesCollectedEvents = _getFeesCollectedEvents;
 // eslint-disable-next-line no-underscore-dangle
-function _getDeposits(vaultAddress, chainId, dex, days) {
-    return __awaiter(this, void 0, void 0, function () {
-        var key, cachedData, ttl, _a, publishedUrl, url, currTimestamp, startTimestamp, depositEvents, endOfData, lastTimestamp, result, error_4, error2_4;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    key = "deposits-".concat(chainId, "-").concat(vaultAddress, "-").concat(days);
-                    cachedData = cache_1.default.get(key);
-                    if (cachedData) {
-                        return [2 /*return*/, cachedData];
-                    }
-                    ttl = 120000;
-                    _a = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true), publishedUrl = _a.publishedUrl, url = _a.url;
-                    currTimestamp = Date.now();
-                    startTimestamp = days
-                        ? parseInt(((currTimestamp - (0, timestamps_1.daysToMilliseconds)(days)) / 1000).toString()).toString()
-                        : '0';
-                    depositEvents = [];
-                    endOfData = false;
-                    lastTimestamp = startTimestamp;
-                    _b.label = 1;
-                case 1:
-                    if (!!endOfData) return [3 /*break*/, 12];
-                    result = void 0;
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 6, , 11]);
-                    if (!publishedUrl) return [3 /*break*/, 4];
-                    return [4 /*yield*/, (0, functions_1.sendDepositsQueryRequest)(publishedUrl, vaultAddress, startTimestamp, (0, queries_1.vaultDepositsQuery)(lastTimestamp))];
-                case 3:
-                    result = _b.sent();
-                    return [3 /*break*/, 5];
-                case 4: throw new Error("Published URL is invalid for dex ".concat(dex, " on chain ").concat(chainId));
-                case 5: return [3 /*break*/, 11];
-                case 6:
-                    error_4 = _b.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_4);
-                    }
-                    _b.label = 7;
-                case 7:
-                    _b.trys.push([7, 9, , 10]);
-                    return [4 /*yield*/, (0, functions_1.sendDepositsQueryRequest)(url, vaultAddress, startTimestamp, (0, queries_1.vaultDepositsQuery)(lastTimestamp))];
-                case 8:
-                    result = _b.sent();
-                    return [3 /*break*/, 10];
-                case 9:
-                    error2_4 = _b.sent();
-                    console.error('Request to public graph URL failed:', error2_4);
-                    throw new Error("Could not get deposits for vault ".concat(vaultAddress, " on chain ").concat(chainId));
-                case 10: return [3 /*break*/, 11];
-                case 11:
-                    if (result && result.length > 0) {
-                        depositEvents.push.apply(depositEvents, result);
-                        if (result.length < 1000) {
-                            endOfData = true;
-                        }
-                        else {
-                            // Update the cursor to the timestamp of the last item
-                            lastTimestamp = result[result.length - 1].createdAtTimestamp;
-                        }
-                    }
-                    else {
-                        endOfData = true;
-                    }
-                    return [3 /*break*/, 1];
-                case 12:
-                    cache_1.default.set(key, depositEvents, ttl);
-                    return [2 /*return*/, depositEvents];
-            }
-        });
-    });
+async function _getDeposits(vaultAddress, chainId, dex, days) {
+    const key = `deposits-${chainId}-${vaultAddress}-${days}`;
+    const cachedData = cache_1.default.get(key);
+    if (cachedData) {
+        return cachedData;
+    }
+    const ttl = 120000;
+    const { publishedUrl, url } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true);
+    const currTimestamp = Date.now();
+    const startTimestamp = days
+        ? parseInt(((currTimestamp - (0, timestamps_1.daysToMilliseconds)(days)) / 1000).toString()).toString()
+        : '0';
+    const depositEvents = [];
+    let endOfData = false;
+    let lastTimestamp = startTimestamp;
+    while (!endOfData) {
+        let result;
+        try {
+            if (publishedUrl) {
+                result = await (0, functions_1.sendDepositsQueryRequest)(publishedUrl, vaultAddress, startTimestamp, (0, queries_1.vaultDepositsQuery)(lastTimestamp));
+            }
+            else {
+                throw new Error(`Published URL is invalid for dex ${dex} on chain ${chainId}`);
+            }
+        }
+        catch (error) {
+            if (publishedUrl) {
+                console.error('Request to published graph URL failed:', error);
+            }
+            try {
+                result = await (0, functions_1.sendDepositsQueryRequest)(url, vaultAddress, startTimestamp, (0, queries_1.vaultDepositsQuery)(lastTimestamp));
+            }
+            catch (error2) {
+                console.error('Request to public graph URL failed:', error2);
+                throw new Error(`Could not get deposits for vault ${vaultAddress} on chain ${chainId}`);
+            }
+        }
+        if (result && result.length > 0) {
+            depositEvents.push(...result);
+            if (result.length < 1000) {
+                endOfData = true;
+            }
+            else {
+                // Update the cursor to the timestamp of the last item
+                lastTimestamp = result[result.length - 1].createdAtTimestamp;
+            }
+        }
+        else {
+            endOfData = true;
+        }
+    }
+    cache_1.default.set(key, depositEvents, ttl);
+    return depositEvents;
 }
 exports._getDeposits = _getDeposits;
 // eslint-disable-next-line no-underscore-dangle
-function _getWithdraws(vaultAddress, chainId, dex, days) {
-    return __awaiter(this, void 0, void 0, function () {
-        var key, cachedData, ttl, _a, publishedUrl, url, currTimestamp, startTimestamp, withdrawEvents, endOfData, lastTimestamp, result, error_5, error2_5;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    key = "withdraws-".concat(chainId, "-").concat(vaultAddress, "-").concat(days);
-                    cachedData = cache_1.default.get(key);
-                    if (cachedData) {
-                        return [2 /*return*/, cachedData];
-                    }
-                    ttl = 120000;
-                    _a = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true), publishedUrl = _a.publishedUrl, url = _a.url;
-                    currTimestamp = Date.now();
-                    startTimestamp = days
-                        ? parseInt(((currTimestamp - (0, timestamps_1.daysToMilliseconds)(days)) / 1000).toString()).toString()
-                        : '0';
-                    withdrawEvents = [];
-                    endOfData = false;
-                    lastTimestamp = startTimestamp;
-                    _b.label = 1;
-                case 1:
-                    if (!!endOfData) return [3 /*break*/, 12];
-                    result = void 0;
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 6, , 11]);
-                    if (!publishedUrl) return [3 /*break*/, 4];
-                    return [4 /*yield*/, (0, functions_1.sendWithdrawsQueryRequest)(publishedUrl, vaultAddress, startTimestamp, (0, queries_1.vaultWithdrawsQuery)(lastTimestamp))];
-                case 3:
-                    result = _b.sent();
-                    return [3 /*break*/, 5];
-                case 4: throw new Error("Published URL is invalid for dex ".concat(dex, " on chain ").concat(chainId));
-                case 5: return [3 /*break*/, 11];
-                case 6:
-                    error_5 = _b.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_5);
-                    }
-                    _b.label = 7;
-                case 7:
-                    _b.trys.push([7, 9, , 10]);
-                    return [4 /*yield*/, (0, functions_1.sendWithdrawsQueryRequest)(url, vaultAddress, startTimestamp, (0, queries_1.vaultWithdrawsQuery)(lastTimestamp))];
-                case 8:
-                    result = _b.sent();
-                    return [3 /*break*/, 10];
-                case 9:
-                    error2_5 = _b.sent();
-                    console.error('Request to public graph URL failed:', error2_5);
-                    throw new Error("Could not get withdraws for vault ".concat(vaultAddress, " on chain ").concat(chainId));
-                case 10: return [3 /*break*/, 11];
-                case 11:
-                    if (result && result.length > 0) {
-                        withdrawEvents.push.apply(withdrawEvents, result);
-                        if (result.length < 1000) {
-                            endOfData = true;
-                        }
-                        else {
-                            // Update the cursor to the timestamp of the last item
-                            lastTimestamp = result[result.length - 1].createdAtTimestamp;
-                        }
-                    }
-                    else {
-                        endOfData = true;
-                    }
-                    return [3 /*break*/, 1];
-                case 12:
-                    cache_1.default.set(key, withdrawEvents, ttl);
-                    return [2 /*return*/, withdrawEvents];
-            }
-        });
-    });
+async function _getWithdraws(vaultAddress, chainId, dex, days) {
+    const key = `withdraws-${chainId}-${vaultAddress}-${days}`;
+    const cachedData = cache_1.default.get(key);
+    if (cachedData) {
+        return cachedData;
+    }
+    const ttl = 120000;
+    const { publishedUrl, url } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true);
+    const currTimestamp = Date.now();
+    const startTimestamp = days
+        ? parseInt(((currTimestamp - (0, timestamps_1.daysToMilliseconds)(days)) / 1000).toString()).toString()
+        : '0';
+    const withdrawEvents = [];
+    let endOfData = false;
+    let lastTimestamp = startTimestamp;
+    while (!endOfData) {
+        let result;
+        try {
+            if (publishedUrl) {
+                result = await (0, functions_1.sendWithdrawsQueryRequest)(publishedUrl, vaultAddress, startTimestamp, (0, queries_1.vaultWithdrawsQuery)(lastTimestamp));
+            }
+            else {
+                throw new Error(`Published URL is invalid for dex ${dex} on chain ${chainId}`);
+            }
+        }
+        catch (error) {
+            if (publishedUrl) {
+                console.error('Request to published graph URL failed:', error);
+            }
+            try {
+                result = await (0, functions_1.sendWithdrawsQueryRequest)(url, vaultAddress, startTimestamp, (0, queries_1.vaultWithdrawsQuery)(lastTimestamp));
+            }
+            catch (error2) {
+                console.error('Request to public graph URL failed:', error2);
+                throw new Error(`Could not get withdraws for vault ${vaultAddress} on chain ${chainId}`);
+            }
+        }
+        if (result && result.length > 0) {
+            withdrawEvents.push(...result);
+            if (result.length < 1000) {
+                endOfData = true;
+            }
+            else {
+                // Update the cursor to the timestamp of the last item
+                lastTimestamp = result[result.length - 1].createdAtTimestamp;
+            }
+        }
+        else {
+            endOfData = true;
+        }
+    }
+    cache_1.default.set(key, withdrawEvents, ttl);
+    return withdrawEvents;
 }
 exports._getWithdraws = _getWithdraws;
 // eslint-disable-next-line no-underscore-dangle
-function _getAllVaultEvents(vaultAddress, chainId, dex, days) {
-    return __awaiter(this, void 0, void 0, function () {
-        var key, cachedData, ttl, allEvents, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    key = "allEvents-".concat(chainId, "-").concat(vaultAddress);
-                    cachedData = cache_1.default.get(key);
-                    if (cachedData) {
-                        return [2 /*return*/, cachedData];
-                    }
-                    ttl = 120000;
-                    return [4 /*yield*/, _getAllEvents(vaultAddress, chainId, dex, days)];
-                case 1:
-                    allEvents = _a.sent();
-                    result = allEvents.sort(function (a, b) { return Number(b.createdAtTimestamp) - Number(a.createdAtTimestamp); });
-                    cache_1.default.set(key, result, ttl);
-                    return [2 /*return*/, result];
-            }
-        });
-    });
+async function _getAllVaultEvents(vaultAddress, chainId, dex, days) {
+    const key = `allEvents-${chainId}-${vaultAddress}`;
+    const cachedData = cache_1.default.get(key);
+    if (cachedData) {
+        return cachedData;
+    }
+    const ttl = 120000;
+    const allEvents = await _getAllEvents(vaultAddress, chainId, dex, days);
+    const result = allEvents.sort((a, b) => Number(b.createdAtTimestamp) - Number(a.createdAtTimestamp));
+    cache_1.default.set(key, result, ttl);
+    return result;
 }
 exports._getAllVaultEvents = _getAllVaultEvents;
 function getVaultStateAt(vaultEvents, daysAgo) {
     if (vaultEvents.length === 0) {
         return null;
     }
-    var eventsBefore = vaultEvents.filter(function (e) { return Number(e.createdAtTimestamp) * 1000 <= Date.now() - (0, timestamps_1.daysToMilliseconds)(daysAgo); });
+    const eventsBefore = vaultEvents.filter((e) => Number(e.createdAtTimestamp) * 1000 <= Date.now() - (0, timestamps_1.daysToMilliseconds)(daysAgo));
     if (eventsBefore.length > 0) {
         return eventsBefore[0];
     }