@ichidao/ichi-vaults-sdk 0.1.42 → 2.0.0

package/dist/src/functions/vault.js

@@ -1,63 +1,21 @@
 "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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAllRewardVaults = exports.getChainByProvider = exports.validateVaultData = exports.getVaultsByPool = exports.getVaultsByTokens = exports.getIchiVaultInfo = void 0;
 // eslint-disable-next-line import/no-unresolved
-var graphql_request_1 = require("graphql-request");
-var types_1 = require("../types");
-var contracts_1 = require("../contracts");
-var queries_1 = require("../graphql/queries");
-var getGraphUrls_1 = require("../utils/getGraphUrls");
-var cache_1 = __importDefault(require("../utils/cache"));
+const graphql_request_1 = require("graphql-request");
+const types_1 = require("../types");
+const contracts_1 = require("../contracts");
+const queries_1 = require("../graphql/queries");
+const getGraphUrls_1 = require("../utils/getGraphUrls");
+const cache_1 = __importDefault(require("../utils/cache"));
 function normalizeVaultData(vaultData) {
-    var _a, _b;
+    // If vaultData is null or undefined, throw an error
+    if (!vaultData) {
+        throw new Error('Vault data is null or undefined');
+    }
     // If it's a v2 response (has token0/token1)
     if ('token0' in vaultData && 'token1' in vaultData) {
         return {
@@ -68,359 +26,221 @@ function normalizeVaultData(vaultData) {
             allowTokenB: vaultData.allowToken1,
             fee: vaultData.fee,
             holdersCount: vaultData.holdersCount,
-            farmingContract: (_a = vaultData.farmingContract) === null || _a === void 0 ? void 0 : _a.id,
-            rewardTokens: (_b = vaultData.farmingContract) === null || _b === void 0 ? void 0 : _b.rewardTokens,
+            farmingContract: vaultData.farmingContract?.id,
+            rewardTokens: vaultData.farmingContract?.rewardTokens,
         };
     }
     // If it's a v1 response (already has tokenA/tokenB)
     return vaultData;
 }
-function getVaultInfoFromContract(vaultAddress, jsonProvider) {
-    return __awaiter(this, void 0, void 0, function () {
-        var vault, vaultContract, _a, _b, _c, _d, error_1;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0:
-                    vault = {
-                        id: vaultAddress,
-                        tokenA: '',
-                        tokenB: '',
-                        allowTokenA: false,
-                        allowTokenB: false,
-                    };
-                    _e.label = 1;
-                case 1:
-                    _e.trys.push([1, 6, , 7]);
-                    vaultContract = (0, contracts_1.getIchiVaultContract)(vaultAddress, jsonProvider);
-                    _a = vault;
-                    return [4 /*yield*/, vaultContract.token0()];
-                case 2:
-                    _a.tokenA = _e.sent();
-                    _b = vault;
-                    return [4 /*yield*/, vaultContract.token1()];
-                case 3:
-                    _b.tokenB = _e.sent();
-                    _c = vault;
-                    return [4 /*yield*/, vaultContract.allowToken0()];
-                case 4:
-                    _c.allowTokenA = _e.sent();
-                    _d = vault;
-                    return [4 /*yield*/, vaultContract.allowToken1()];
-                case 5:
-                    _d.allowTokenB = _e.sent();
-                    return [3 /*break*/, 7];
-                case 6:
-                    error_1 = _e.sent();
-                    throw new Error("Could not get vault info for ".concat(vaultAddress));
-                case 7: return [2 /*return*/, vault];
-            }
-        });
-    });
+async function getVaultInfoFromContract(vaultAddress, jsonProvider) {
+    const vault = {
+        id: vaultAddress,
+        tokenA: '',
+        tokenB: '',
+        allowTokenA: false,
+        allowTokenB: false,
+    };
+    try {
+        const vaultContract = (0, contracts_1.getIchiVaultContract)(vaultAddress, jsonProvider);
+        vault.tokenA = await vaultContract.token0();
+        vault.tokenB = await vaultContract.token1();
+        vault.allowTokenA = await vaultContract.allowToken0();
+        vault.allowTokenB = await vaultContract.allowToken1();
+    }
+    catch (error) {
+        throw new Error(`Could not get vault info for ${vaultAddress}`);
+    }
+    return vault;
 }
-function sendVaultQueryRequest(url, vaultAddress, query) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, (0, graphql_request_1.request)(url, query, {
-                    vaultAddress: vaultAddress.toLowerCase(),
-                }).then(function (_a) {
-                    var ichiVault = _a.ichiVault;
-                    return ichiVault;
-                })];
-        });
-    });
+async function sendVaultQueryRequest(url, vaultAddress, query) {
+    return (0, graphql_request_1.request)(url, query, {
+        vaultAddress: vaultAddress.toLowerCase(),
+    }).then(({ ichiVault }) => ichiVault);
 }
-function sendVaultsByTokensRequest(url, token1, token2, query) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, (0, graphql_request_1.request)(url, query, {
-                    addressTokenA: token1,
-                    addressTokenB: token2,
-                }).then(function (_a) {
-                    var ichiVaults = _a.ichiVaults;
-                    return ichiVaults;
-                })];
-        });
-    });
+async function sendVaultsByTokensRequest(url, token1, token2, query) {
+    return (0, graphql_request_1.request)(url, query, {
+        addressTokenA: token1,
+        addressTokenB: token2,
+    }).then(({ ichiVaults }) => ichiVaults);
 }
-function sendVaultsByPoolQueryRequest(url, poolAddress, query) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, (0, graphql_request_1.request)(url, query, {
-                    poolAddress: poolAddress.toLowerCase(),
-                }).then(function (_a) {
-                    var deployICHIVaults = _a.deployICHIVaults;
-                    return deployICHIVaults;
-                })];
-        });
-    });
+async function sendVaultsByPoolQueryRequest(url, poolAddress, query) {
+    return (0, graphql_request_1.request)(url, query, {
+        poolAddress: poolAddress.toLowerCase(),
+    }).then(({ deployICHIVaults }) => deployICHIVaults);
 }
-function sendAllRewardVaultsQueryRequest(url, query) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, (0, graphql_request_1.request)(url, query).then(function (_a) {
-                    var ichiVaults = _a.ichiVaults;
-                    return ichiVaults;
-                })];
-        });
-    });
+async function sendAllRewardVaultsQueryRequest(url, query) {
+    return (0, graphql_request_1.request)(url, query).then(({ ichiVaults }) => ichiVaults);
 }
-function getIchiVaultInfo(chainId, dex, vaultAddress, jsonProvider) {
-    return __awaiter(this, void 0, void 0, function () {
-        var key, ttl, cachedData, _a, url, publishedUrl, thisQuery, result, result, normalizedResult, error_2, result, normalizedResult, error2_1, result;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    key = "vault-".concat(chainId, "-").concat(vaultAddress);
-                    ttl = 6 * 60 * 60 * 1000;
-                    cachedData = cache_1.default.get(key);
-                    if (cachedData) {
-                        return [2 /*return*/, cachedData];
-                    }
-                    _a = (0, getGraphUrls_1.getGraphUrls)(chainId, dex), url = _a.url, publishedUrl = _a.publishedUrl;
-                    thisQuery = (0, queries_1.getVaultQuery)(chainId, dex);
-                    if (!(url === 'none' && jsonProvider)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, getVaultInfoFromContract(vaultAddress, jsonProvider)];
-                case 1:
-                    result = _b.sent();
-                    cache_1.default.set(key, result, ttl);
-                    return [2 /*return*/, result];
-                case 2:
-                    _b.trys.push([2, 5, , 13]);
-                    if (!publishedUrl) return [3 /*break*/, 4];
-                    return [4 /*yield*/, sendVaultQueryRequest(publishedUrl, vaultAddress, thisQuery)];
-                case 3:
-                    result = _b.sent();
-                    normalizedResult = normalizeVaultData(result);
-                    cache_1.default.set(key, normalizedResult, ttl);
-                    return [2 /*return*/, normalizedResult];
-                case 4: throw new Error("Published URL is invalid for ".concat(vaultAddress));
-                case 5:
-                    error_2 = _b.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_2);
-                    }
-                    _b.label = 6;
-                case 6:
-                    _b.trys.push([6, 8, , 12]);
-                    return [4 /*yield*/, sendVaultQueryRequest(url, vaultAddress, thisQuery)];
-                case 7:
-                    result = _b.sent();
-                    normalizedResult = normalizeVaultData(result);
-                    cache_1.default.set(key, normalizedResult, ttl);
-                    return [2 /*return*/, normalizedResult];
-                case 8:
-                    error2_1 = _b.sent();
-                    console.error('Request to public graph URL failed:', error2_1);
-                    if (!jsonProvider) return [3 /*break*/, 10];
-                    return [4 /*yield*/, getVaultInfoFromContract(vaultAddress, jsonProvider)];
-                case 9:
-                    result = _b.sent();
-                    cache_1.default.set(key, result, ttl);
-                    return [2 /*return*/, result];
-                case 10: throw new Error("Could not get vault info for ".concat(vaultAddress));
-                case 11: return [3 /*break*/, 12];
-                case 12: return [3 /*break*/, 13];
-                case 13: return [2 /*return*/];
+async function getIchiVaultInfo(chainId, dex, vaultAddress, jsonProvider) {
+    const key = `vault-${chainId}-${vaultAddress}`;
+    const ttl = 6 * 60 * 60 * 1000; // 6 hours
+    const cachedData = cache_1.default.get(key);
+    if (cachedData) {
+        return cachedData;
+    }
+    const { url, publishedUrl } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex);
+    const thisQuery = (0, queries_1.getVaultQuery)(chainId, dex);
+    if (url === 'none' && jsonProvider) {
+        const result = await getVaultInfoFromContract(vaultAddress, jsonProvider);
+        cache_1.default.set(key, result, ttl);
+        return result;
+    }
+    try {
+        if (publishedUrl) {
+            const result = await sendVaultQueryRequest(publishedUrl, vaultAddress, thisQuery);
+            const normalizedResult = normalizeVaultData(result);
+            cache_1.default.set(key, normalizedResult, ttl);
+            return normalizedResult;
+        }
+        throw new Error(`Published URL is invalid for ${vaultAddress}`);
+    }
+    catch (error) {
+        if (publishedUrl) {
+            console.error('Request to published graph URL failed:', error);
+        }
+        try {
+            const result = await sendVaultQueryRequest(url, vaultAddress, thisQuery);
+            const normalizedResult = normalizeVaultData(result);
+            cache_1.default.set(key, normalizedResult, ttl);
+            return normalizedResult;
+        }
+        catch (error2) {
+            console.error('Request to public graph URL failed:', error2);
+            if (jsonProvider) {
+                const result = await getVaultInfoFromContract(vaultAddress, jsonProvider);
+                cache_1.default.set(key, result, ttl);
+                return result;
+            }
+            else {
+                throw new Error(`Could not get vault info for ${vaultAddress}`);
             }
-        });
-    });
+        }
+    }
 }
 exports.getIchiVaultInfo = getIchiVaultInfo;
-function getVaultsByTokensAB(chainId, dex, tokenA, tokenB) {
-    return __awaiter(this, void 0, void 0, function () {
-        var key, cachedData, ttl, _a, url, publishedUrl, version, strVaultByTokensQuery, result, error_3, result, error2_2;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    key = "vaultByTokens-".concat(chainId, "-").concat(tokenA, "-").concat(tokenB);
-                    cachedData = cache_1.default.get(key);
-                    if (cachedData) {
-                        return [2 /*return*/, cachedData];
-                    }
-                    ttl = 3600000;
-                    _a = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true), url = _a.url, publishedUrl = _a.publishedUrl, version = _a.version;
-                    strVaultByTokensQuery = (0, queries_1.vaultByTokensQuery)(version);
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 5, , 10]);
-                    if (!publishedUrl) return [3 /*break*/, 3];
-                    return [4 /*yield*/, sendVaultsByTokensRequest(publishedUrl, tokenA, tokenB, strVaultByTokensQuery)];
-                case 2:
-                    result = _b.sent();
-                    cache_1.default.set(key, result, ttl);
-                    return [2 /*return*/, result];
-                case 3: throw new Error("Published URL is invalid for dex ".concat(dex, " on chain ").concat(chainId));
-                case 4: return [3 /*break*/, 10];
-                case 5:
-                    error_3 = _b.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_3);
-                    }
-                    _b.label = 6;
-                case 6:
-                    _b.trys.push([6, 8, , 9]);
-                    return [4 /*yield*/, sendVaultsByTokensRequest(url, tokenA, tokenB, strVaultByTokensQuery)];
-                case 7:
-                    result = _b.sent();
-                    cache_1.default.set(key, result, ttl);
-                    return [2 /*return*/, result];
-                case 8:
-                    error2_2 = _b.sent();
-                    console.error('Request to public graph URL failed:', error2_2);
-                    throw new Error("Could not get vaults by tokens, dex ".concat(dex, " on chain ").concat(chainId));
-                case 9: return [3 /*break*/, 10];
-                case 10: return [2 /*return*/];
-            }
-        });
-    });
+async function getVaultsByTokensAB(chainId, dex, tokenA, tokenB) {
+    const key = `vaultByTokens-${chainId}-${tokenA}-${tokenB}`;
+    const cachedData = cache_1.default.get(key);
+    if (cachedData) {
+        return cachedData;
+    }
+    const ttl = 3600000;
+    const { url, publishedUrl, version } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true);
+    const strVaultByTokensQuery = (0, queries_1.vaultByTokensQuery)(version);
+    try {
+        if (publishedUrl) {
+            const result = await sendVaultsByTokensRequest(publishedUrl, tokenA, tokenB, strVaultByTokensQuery);
+            cache_1.default.set(key, result, ttl);
+            return result;
+        }
+        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 {
+            const result = await sendVaultsByTokensRequest(url, tokenA, tokenB, strVaultByTokensQuery);
+            cache_1.default.set(key, result, ttl);
+            return result;
+        }
+        catch (error2) {
+            console.error('Request to public graph URL failed:', error2);
+            throw new Error(`Could not get vaults by tokens, dex ${dex} on chain ${chainId}`);
+        }
+    }
 }
-function getVaultsByTokens(chainId, dex, depositTokenAddress, pairedTokenAddress) {
-    return __awaiter(this, void 0, void 0, function () {
-        var arrVaults1, arrVaults2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getVaultsByTokensAB(chainId, dex, depositTokenAddress, pairedTokenAddress)];
-                case 1:
-                    arrVaults1 = (_a.sent()).filter(function (v) { return v.allowTokenA; });
-                    return [4 /*yield*/, getVaultsByTokensAB(chainId, dex, pairedTokenAddress, depositTokenAddress)];
-                case 2:
-                    arrVaults2 = (_a.sent()).filter(function (v) { return v.allowTokenB; });
-                    // eslint-disable-next-line no-return-await
-                    return [2 /*return*/, __spreadArray(__spreadArray([], arrVaults1, true), arrVaults2, true)];
-            }
-        });
-    });
+async function getVaultsByTokens(chainId, dex, depositTokenAddress, pairedTokenAddress) {
+    const arrVaults1 = (await getVaultsByTokensAB(chainId, dex, depositTokenAddress, pairedTokenAddress)).filter((v) => v.allowTokenA);
+    const arrVaults2 = (await getVaultsByTokensAB(chainId, dex, pairedTokenAddress, depositTokenAddress)).filter((v) => v.allowTokenB);
+    // eslint-disable-next-line no-return-await
+    return [...arrVaults1, ...arrVaults2];
 }
 exports.getVaultsByTokens = getVaultsByTokens;
-function getVaultsByPool(poolAddress, chainId, dex) {
-    return __awaiter(this, void 0, void 0, function () {
-        var key, cachedData, _a, url, publishedUrl, ttl, result, error_4, result, error2_3;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    key = "pool-".concat(chainId, "-").concat(poolAddress);
-                    cachedData = cache_1.default.get(key);
-                    if (cachedData) {
-                        return [2 /*return*/, cachedData];
-                    }
-                    _a = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true), url = _a.url, publishedUrl = _a.publishedUrl;
-                    ttl = 3600000;
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 4, , 9]);
-                    if (!publishedUrl) return [3 /*break*/, 3];
-                    return [4 /*yield*/, sendVaultsByPoolQueryRequest(publishedUrl, poolAddress, queries_1.vaultByPoolQuery)];
-                case 2:
-                    result = _b.sent();
-                    cache_1.default.set(key, result, ttl);
-                    return [2 /*return*/, result];
-                case 3: throw new Error("Published URL is invalid for dex ".concat(dex, " on chain ").concat(chainId));
-                case 4:
-                    error_4 = _b.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_4);
-                    }
-                    _b.label = 5;
-                case 5:
-                    _b.trys.push([5, 7, , 8]);
-                    return [4 /*yield*/, sendVaultsByPoolQueryRequest(url, poolAddress, queries_1.vaultByPoolQuery)];
-                case 6:
-                    result = _b.sent();
-                    cache_1.default.set(key, result, ttl);
-                    return [2 /*return*/, result];
-                case 7:
-                    error2_3 = _b.sent();
-                    console.error('Request to public graph URL failed:', error2_3);
-                    throw new Error("Could not get vaults by pool ".concat(poolAddress));
-                case 8: return [3 /*break*/, 9];
-                case 9: return [2 /*return*/];
-            }
-        });
-    });
+async function getVaultsByPool(poolAddress, chainId, dex) {
+    const key = `pool-${chainId}-${poolAddress}`;
+    const cachedData = cache_1.default.get(key);
+    if (cachedData) {
+        return cachedData;
+    }
+    const { url, publishedUrl } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true);
+    const ttl = 3600000;
+    try {
+        if (publishedUrl) {
+            const result = await sendVaultsByPoolQueryRequest(publishedUrl, poolAddress, queries_1.vaultByPoolQuery);
+            cache_1.default.set(key, result, ttl);
+            return result;
+        }
+        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 {
+            const result = await sendVaultsByPoolQueryRequest(url, poolAddress, queries_1.vaultByPoolQuery);
+            cache_1.default.set(key, result, ttl);
+            return result;
+        }
+        catch (error2) {
+            console.error('Request to public graph URL failed:', error2);
+            throw new Error(`Could not get vaults by pool ${poolAddress}`);
+        }
+    }
 }
 exports.getVaultsByPool = getVaultsByPool;
-function validateVaultData(vaultAddress, jsonProvider, dex) {
-    return __awaiter(this, void 0, void 0, function () {
-        var chainId, vault;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, jsonProvider.getNetwork()];
-                case 1:
-                    chainId = (_a.sent()).chainId;
-                    if (!Object.values(types_1.SupportedChainId).includes(chainId)) {
-                        throw new Error("Unsupported chainId: ".concat(chainId !== null && chainId !== void 0 ? chainId : 'undefined'));
-                    }
-                    return [4 /*yield*/, getIchiVaultInfo(chainId, dex, vaultAddress, jsonProvider)];
-                case 2:
-                    vault = _a.sent();
-                    return [2 /*return*/, { chainId: chainId, vault: vault }];
-            }
-        });
-    });
+async function validateVaultData(vaultAddress, jsonProvider, dex) {
+    const network = await jsonProvider.getNetwork();
+    const chainId = Number(network.chainId);
+    if (!Object.values(types_1.SupportedChainId).includes(chainId)) {
+        throw new Error(`Unsupported chainId: ${chainId ?? 'undefined'}`);
+    }
+    const vault = await getIchiVaultInfo(chainId, dex, vaultAddress, jsonProvider);
+    return { chainId, vault };
 }
 exports.validateVaultData = validateVaultData;
-function getChainByProvider(jsonProvider) {
-    return __awaiter(this, void 0, void 0, function () {
-        var chainId;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, jsonProvider.getNetwork()];
-                case 1:
-                    chainId = (_a.sent()).chainId;
-                    if (!Object.values(types_1.SupportedChainId).includes(chainId)) {
-                        throw new Error("Unsupported chainId: ".concat(chainId !== null && chainId !== void 0 ? chainId : 'undefined'));
-                    }
-                    return [2 /*return*/, { chainId: chainId }];
-            }
-        });
-    });
+async function getChainByProvider(jsonProvider) {
+    const network = await jsonProvider.getNetwork();
+    const chainId = Number(network.chainId);
+    if (!Object.values(types_1.SupportedChainId).includes(chainId)) {
+        throw new Error(`Unsupported chainId: ${chainId ?? 'undefined'}`);
+    }
+    return { chainId };
 }
 exports.getChainByProvider = getChainByProvider;
-function getAllRewardVaults(chainId, dex) {
-    return __awaiter(this, void 0, void 0, function () {
-        var key, cachedData, _a, url, publishedUrl, ttl, result, error_5, result, error2_4;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    key = "allvaults-".concat(chainId, "-").concat(dex);
-                    cachedData = cache_1.default.get(key);
-                    if (cachedData) {
-                        return [2 /*return*/, cachedData];
-                    }
-                    _a = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true), url = _a.url, publishedUrl = _a.publishedUrl;
-                    ttl = 3600000;
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 4, , 9]);
-                    if (!publishedUrl) return [3 /*break*/, 3];
-                    return [4 /*yield*/, sendAllRewardVaultsQueryRequest(publishedUrl, queries_1.allRewardVaults)];
-                case 2:
-                    result = _b.sent();
-                    cache_1.default.set(key, result, ttl);
-                    return [2 /*return*/, result];
-                case 3: throw new Error("Published URL is invalid for dex ".concat(dex, " on chain ").concat(chainId));
-                case 4:
-                    error_5 = _b.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_5);
-                    }
-                    _b.label = 5;
-                case 5:
-                    _b.trys.push([5, 7, , 8]);
-                    return [4 /*yield*/, sendAllRewardVaultsQueryRequest(url, queries_1.allRewardVaults)];
-                case 6:
-                    result = _b.sent();
-                    cache_1.default.set(key, result, ttl);
-                    return [2 /*return*/, result];
-                case 7:
-                    error2_4 = _b.sent();
-                    console.error('Request to public graph URL failed:', error2_4);
-                    throw new Error("Could not get reward vaults on dex ".concat(dex));
-                case 8: return [3 /*break*/, 9];
-                case 9: return [2 /*return*/];
-            }
-        });
-    });
+async function getAllRewardVaults(chainId, dex) {
+    const key = `allvaults-${chainId}-${dex}`;
+    const cachedData = cache_1.default.get(key);
+    if (cachedData) {
+        return cachedData;
+    }
+    const { url, publishedUrl } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true);
+    const ttl = 3600000;
+    try {
+        if (publishedUrl) {
+            const result = await sendAllRewardVaultsQueryRequest(publishedUrl, queries_1.allRewardVaults);
+            cache_1.default.set(key, result, ttl);
+            return result;
+        }
+        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 {
+            const result = await sendAllRewardVaultsQueryRequest(url, queries_1.allRewardVaults);
+            cache_1.default.set(key, result, ttl);
+            return result;
+        }
+        catch (error2) {
+            console.error('Request to public graph URL failed:', error2);
+            throw new Error(`Could not get reward vaults on dex ${dex}`);
+        }
+    }
 }
 exports.getAllRewardVaults = getAllRewardVaults;
 //# sourceMappingURL=vault.js.map