@ichidao/ichi-vaults-sdk 0.1.43 → 2.0.1

package/dist/src/functions/userBalances.js

@@ -1,62 +1,25 @@
 "use strict";
 /* eslint-disable no-redeclare */
 /* eslint-disable import/prefer-default-export */
-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.getAllUserAmounts = exports.getUserAmounts = exports.getAllUserBalances = exports.sendUserBalancesQueryRequest = exports.getUserBalance = void 0;
-var ethers_1 = require("ethers");
 // eslint-disable-next-line import/no-unresolved
-var graphql_request_1 = require("graphql-request");
-var contracts_1 = require("../contracts");
-var types_1 = require("../types");
-var formatBigInt_1 = __importDefault(require("../utils/formatBigInt"));
+const graphql_request_1 = require("graphql-request");
+const contracts_1 = require("../contracts");
+const types_1 = require("../types");
+const formatBigInt_1 = __importDefault(require("../utils/formatBigInt"));
 // eslint-disable-next-line import/no-cycle
-var vault_1 = require("./vault");
-var queries_1 = require("../graphql/queries");
-var parseBigInt_1 = __importDefault(require("../utils/parseBigInt"));
-var getGraphUrls_1 = require("../utils/getGraphUrls");
-var _totalBalances_1 = require("./_totalBalances");
-var multicallUtils_1 = require("../utils/multicallUtils");
-var isVelodrome_1 = require("../utils/isVelodrome");
-var promises = {};
+const vault_1 = require("./vault");
+const queries_1 = require("../graphql/queries");
+const parseBigInt_1 = __importDefault(require("../utils/parseBigInt"));
+const getGraphUrls_1 = require("../utils/getGraphUrls");
+const _totalBalances_1 = require("./_totalBalances");
+const multicallUtils_1 = require("../utils/multicallUtils");
+const isVelodrome_1 = require("../utils/isVelodrome");
+const promises = {};
 /**
  * Helper function to get token address regardless of naming convention (token0/1 or tokenA/B)
  * @param vault The vault object from API
@@ -72,345 +35,258 @@ function getTokenAddress(vault, index) {
     }
 }
 // eslint-disable-next-line no-underscore-dangle
-function _getUserBalance(accountAddress, vaultAddress, jsonProvider, farmingContract, raw) {
-    return __awaiter(this, void 0, void 0, function () {
-        var shares, vaultContract, mdfContract, _a, _b, vaultContract;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    if (!farmingContract) return [3 /*break*/, 3];
-                    vaultContract = (0, contracts_1.getIchiVaultContract)(vaultAddress, jsonProvider);
-                    mdfContract = (0, contracts_1.getMultiFeeDistributorContract)(farmingContract, jsonProvider);
-                    return [4 /*yield*/, vaultContract.balanceOf(accountAddress)];
-                case 1:
-                    _b = (_a = (_c.sent())).add;
-                    return [4 /*yield*/, mdfContract.totalBalance(accountAddress)];
-                case 2:
-                    shares = _b.apply(_a, [_c.sent()]);
-                    return [3 /*break*/, 5];
-                case 3:
-                    vaultContract = (0, contracts_1.getIchiVaultContract)(vaultAddress, jsonProvider);
-                    return [4 /*yield*/, vaultContract.balanceOf(accountAddress)];
-                case 4:
-                    shares = _c.sent();
-                    _c.label = 5;
-                case 5: return [2 /*return*/, raw ? shares : (0, formatBigInt_1.default)(shares, types_1.ichiVaultDecimals)];
-            }
-        });
-    });
+async function _getUserBalance(accountAddress, vaultAddress, jsonProvider, farmingContract, raw) {
+    let shares;
+    // if there is farmingContract, balance is the sum of staked and unstaked amounts
+    if (farmingContract) {
+        const vaultContract = (0, contracts_1.getIchiVaultContract)(vaultAddress, jsonProvider);
+        const mdfContract = (0, contracts_1.getMultiFeeDistributorContract)(farmingContract, jsonProvider);
+        shares = (await vaultContract.balanceOf(accountAddress)) + (await mdfContract.totalBalance(accountAddress));
+    }
+    else {
+        const vaultContract = (0, contracts_1.getIchiVaultContract)(vaultAddress, jsonProvider);
+        shares = await vaultContract.balanceOf(accountAddress);
+    }
+    return raw ? shares : (0, formatBigInt_1.default)(shares, types_1.ichiVaultDecimals);
 }
-function getUserBalance(accountAddress, vaultAddress, jsonProvider, dex, raw) {
-    return __awaiter(this, void 0, void 0, function () {
-        var vault;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, (0, vault_1.validateVaultData)(vaultAddress, jsonProvider, dex)];
-                case 1:
-                    vault = (_a.sent()).vault;
-                    return [2 /*return*/, raw
-                            ? _getUserBalance(accountAddress, vaultAddress, jsonProvider, vault.farmingContract || null, true)
-                            : _getUserBalance(accountAddress, vaultAddress, jsonProvider, vault.farmingContract || null)];
-            }
-        });
-    });
+async function getUserBalance(accountAddress, vaultAddress, jsonProvider, dex, raw) {
+    // eslint-disable-next-line no-return-await
+    const { vault } = await (0, vault_1.validateVaultData)(vaultAddress, jsonProvider, dex);
+    return raw
+        ? _getUserBalance(accountAddress, vaultAddress, jsonProvider, vault.farmingContract || null, true)
+        : _getUserBalance(accountAddress, vaultAddress, jsonProvider, vault.farmingContract || null);
 }
 exports.getUserBalance = getUserBalance;
-function sendUserBalancesQueryRequest(url, accountAddress, query, vaultAddress) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            if (vaultAddress) {
-                return [2 /*return*/, (0, graphql_request_1.request)(url, query, {
-                        accountAddress: accountAddress.toLowerCase(),
-                        vaultAddress: vaultAddress.toLowerCase(),
-                    }).then(function (_a) {
-                        var user = _a.user;
-                        return user;
-                    })];
-            }
-            else {
-                return [2 /*return*/, (0, graphql_request_1.request)(url, query, {
-                        accountAddress: accountAddress.toLowerCase(),
-                    }).then(function (_a) {
-                        var user = _a.user;
-                        return user;
-                    })];
-            }
-            return [2 /*return*/];
-        });
-    });
+async function sendUserBalancesQueryRequest(url, accountAddress, query, vaultAddress) {
+    if (vaultAddress) {
+        return (0, graphql_request_1.request)(url, query, {
+            accountAddress: accountAddress.toLowerCase(),
+            vaultAddress: vaultAddress.toLowerCase(),
+        }).then(({ user }) => user);
+    }
+    else {
+        return (0, graphql_request_1.request)(url, query, {
+            accountAddress: accountAddress.toLowerCase(),
+        }).then(({ user }) => user);
+    }
 }
 exports.sendUserBalancesQueryRequest = sendUserBalancesQueryRequest;
 function storeResult(key, result) {
-    var cacheTtl = process.env.CACHE_TTL && !Number.isNaN(process.env.CACHE_TTL) ? Number(process.env.CACHE_TTL) : 120000; // 120000 = 2min
+    const cacheTtl = process.env.CACHE_TTL && !Number.isNaN(process.env.CACHE_TTL) ? Number(process.env.CACHE_TTL) : 120000; // 120000 = 2min
     promises[key] = Promise.resolve(result);
-    setTimeout(function () {
+    setTimeout(() => {
         delete promises[key];
     }, cacheTtl);
 }
-function getAllUserBalances(accountAddress, jsonProvider, dex, raw) {
-    return __awaiter(this, void 0, void 0, function () {
-        var chainId, _a, publishedUrl, url, isVelodrome, shares, key, strUserBalancesQuery, result, error_1, result, error2_1, balances, userBalances;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, (0, vault_1.getChainByProvider)(jsonProvider)];
-                case 1:
-                    chainId = (_b.sent()).chainId;
-                    _a = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true), publishedUrl = _a.publishedUrl, url = _a.url;
-                    isVelodrome = (0, isVelodrome_1.isVelodromeDex)(chainId, dex);
-                    key = "".concat(chainId + accountAddress, "-balances");
-                    if (!!Object.prototype.hasOwnProperty.call(promises, key)) return [3 /*break*/, 11];
-                    strUserBalancesQuery = (0, queries_1.getUserBalancesQuery)(chainId, dex);
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 6, , 11]);
-                    if (!publishedUrl) return [3 /*break*/, 4];
-                    return [4 /*yield*/, sendUserBalancesQueryRequest(publishedUrl, accountAddress, strUserBalancesQuery)];
-                case 3:
-                    result = _b.sent();
-                    storeResult(key, result);
-                    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 = _b.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_1);
-                    }
-                    _b.label = 7;
-                case 7:
-                    _b.trys.push([7, 9, , 10]);
-                    return [4 /*yield*/, sendUserBalancesQueryRequest(url, accountAddress, strUserBalancesQuery)];
-                case 8:
-                    result = _b.sent();
-                    storeResult(key, result);
-                    return [3 /*break*/, 10];
-                case 9:
-                    error2_1 = _b.sent();
-                    console.error('Request to public graph URL failed:', error2_1);
-                    throw new Error("Could not get user balances for ".concat(accountAddress, " on chain ").concat(chainId));
-                case 10: return [3 /*break*/, 11];
-                case 11: return [4 /*yield*/, promises[key]];
-                case 12:
-                    balances = _b.sent();
-                    if (balances) {
-                        userBalances = balances.vaultShares;
-                        shares = userBalances.map(function (balance) {
-                            var vShares = isVelodrome
-                                ? (Number(balance.vaultShareBalance) + Number(balance.stakedVaultShareBalance)).toString()
-                                : balance.vaultShareBalance;
-                            return isVelodrome
-                                ? { vaultAddress: balance.vault.id, shares: vShares, stakedShares: balance.stakedVaultShareBalance }
-                                : { vaultAddress: balance.vault.id, shares: balance.vaultShareBalance };
-                        });
-                        return [2 /*return*/, raw
-                                ? shares.map(function (s) {
-                                    return isVelodrome
-                                        ? {
-                                            vaultAddress: s.vaultAddress,
-                                            shares: (0, parseBigInt_1.default)(s.shares, types_1.ichiVaultDecimals),
-                                            stakedShares: (0, parseBigInt_1.default)(s.stakedShares || '0', types_1.ichiVaultDecimals),
-                                        }
-                                        : { vaultAddress: s.vaultAddress, shares: (0, parseBigInt_1.default)(s.shares, types_1.ichiVaultDecimals) };
-                                })
-                                : shares];
-                    }
-                    else {
-                        return [2 /*return*/, []];
-                    }
-                    return [2 /*return*/];
+async function getAllUserBalances(accountAddress, jsonProvider, dex, raw) {
+    const { chainId } = await (0, vault_1.getChainByProvider)(jsonProvider);
+    const { publishedUrl, url } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true);
+    const isVelodrome = (0, isVelodrome_1.isVelodromeDex)(chainId, dex);
+    let shares;
+    const key = `${chainId + accountAddress}-balances`;
+    if (!Object.prototype.hasOwnProperty.call(promises, key)) {
+        const strUserBalancesQuery = (0, queries_1.getUserBalancesQuery)(chainId, dex);
+        try {
+            if (publishedUrl) {
+                const result = await sendUserBalancesQueryRequest(publishedUrl, accountAddress, strUserBalancesQuery);
+                storeResult(key, 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 sendUserBalancesQueryRequest(url, accountAddress, strUserBalancesQuery);
+                storeResult(key, result);
+            }
+            catch (error2) {
+                console.error('Request to public graph URL failed:', error2);
+                throw new Error(`Could not get user balances for ${accountAddress} on chain ${chainId}`);
+            }
+        }
+    }
+    const balances = await promises[key];
+    if (balances) {
+        const userBalances = balances.vaultShares;
+        shares = userBalances.map((balance) => {
+            const vShares = isVelodrome
+                ? (Number(balance.vaultShareBalance) + Number(balance.stakedVaultShareBalance)).toString()
+                : balance.vaultShareBalance;
+            return isVelodrome
+                ? { vaultAddress: balance.vault.id, shares: vShares, stakedShares: balance.stakedVaultShareBalance }
+                : { vaultAddress: balance.vault.id, shares: balance.vaultShareBalance };
         });
-    });
+        return raw
+            ? shares.map((s) => {
+                return isVelodrome
+                    ? {
+                        vaultAddress: s.vaultAddress,
+                        shares: (0, parseBigInt_1.default)(s.shares, types_1.ichiVaultDecimals),
+                        stakedShares: (0, parseBigInt_1.default)(s.stakedShares || '0', types_1.ichiVaultDecimals),
+                    }
+                    : { vaultAddress: s.vaultAddress, shares: (0, parseBigInt_1.default)(s.shares, types_1.ichiVaultDecimals) };
+            })
+            : shares;
+    }
+    else {
+        return [];
+    }
 }
 exports.getAllUserBalances = getAllUserBalances;
-function getUserAmounts(accountAddress, vaultAddress, jsonProvider, dex, raw) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, chainId, vault, totalAmountsBN, totalSupplyBN, userBalanceBN, userAmountsBN, token0Decimals, token1Decimals, userAmounts;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, (0, vault_1.validateVaultData)(vaultAddress, jsonProvider, dex)];
-                case 1:
-                    _a = _b.sent(), chainId = _a.chainId, vault = _a.vault;
-                    return [4 /*yield*/, (0, _totalBalances_1._getTotalAmounts)(vault, jsonProvider, chainId, true)];
-                case 2:
-                    totalAmountsBN = _b.sent();
-                    return [4 /*yield*/, (0, _totalBalances_1._getTotalSupply)(vaultAddress, jsonProvider, true)];
-                case 3:
-                    totalSupplyBN = _b.sent();
-                    return [4 /*yield*/, _getUserBalance(accountAddress, vaultAddress, jsonProvider, vault.farmingContract || null, true)];
-                case 4:
-                    userBalanceBN = _b.sent();
-                    if (!!totalSupplyBN.isZero()) return [3 /*break*/, 9];
-                    userAmountsBN = {
-                        amount0: userBalanceBN.mul(totalAmountsBN[0]).div(totalSupplyBN),
-                        amount1: userBalanceBN.mul(totalAmountsBN[1]).div(totalSupplyBN),
-                        0: userBalanceBN.mul(totalAmountsBN[0]).div(totalSupplyBN),
-                        1: userBalanceBN.mul(totalAmountsBN[1]).div(totalSupplyBN),
+async function getUserAmounts(accountAddress, vaultAddress, jsonProvider, dex, raw) {
+    const { chainId, vault } = await (0, vault_1.validateVaultData)(vaultAddress, jsonProvider, dex);
+    const totalAmountsBN = await (0, _totalBalances_1._getTotalAmounts)(vault, jsonProvider, chainId, true);
+    const totalSupplyBN = await (0, _totalBalances_1._getTotalSupply)(vaultAddress, jsonProvider, true);
+    const userBalanceBN = await _getUserBalance(accountAddress, vaultAddress, jsonProvider, vault.farmingContract || null, true);
+    if (totalSupplyBN !== 0n) {
+        const userAmountsBN = {
+            amount0: (userBalanceBN * totalAmountsBN[0]) / totalSupplyBN,
+            amount1: (userBalanceBN * totalAmountsBN[1]) / totalSupplyBN,
+            0: (userBalanceBN * totalAmountsBN[0]) / totalSupplyBN,
+            1: (userBalanceBN * totalAmountsBN[1]) / totalSupplyBN,
+        };
+        if (!raw) {
+            const token0Decimals = await (0, _totalBalances_1.getTokenDecimals)(vault.tokenA, jsonProvider, chainId);
+            const token1Decimals = await (0, _totalBalances_1.getTokenDecimals)(vault.tokenB, jsonProvider, chainId);
+            const userAmounts = {
+                amount0: (0, formatBigInt_1.default)(userAmountsBN.amount0, token0Decimals),
+                amount1: (0, formatBigInt_1.default)(userAmountsBN.amount1, token1Decimals),
+                0: (0, formatBigInt_1.default)(userAmountsBN.amount0, token0Decimals),
+                1: (0, formatBigInt_1.default)(userAmountsBN.amount1, token1Decimals),
+            };
+            return userAmounts;
+        }
+        else {
+            return userAmountsBN;
+        }
+    }
+    else if (!raw) {
+        return {
+            amount0: '0',
+            amount1: '0',
+            0: '0',
+            1: '0',
+        };
+    }
+    else {
+        return {
+            amount0: 0n,
+            amount1: 0n,
+            0: 0n,
+            1: 0n,
+        };
+    }
+}
+exports.getUserAmounts = getUserAmounts;
+async function getAllUserAmounts(accountAddress, jsonProvider, dex, raw) {
+    const { chainId } = await (0, vault_1.getChainByProvider)(jsonProvider);
+    const { publishedUrl, url } = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true);
+    const key = `${chainId + accountAddress}-all-user-amounts`;
+    if (!Object.prototype.hasOwnProperty.call(promises, key)) {
+        const strUserBalancesQuery = (0, queries_1.getUserBalancesQuery)(chainId, dex);
+        try {
+            if (publishedUrl) {
+                const result = await sendUserBalancesQueryRequest(publishedUrl, accountAddress, strUserBalancesQuery);
+                storeResult(key, 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 sendUserBalancesQueryRequest(url, accountAddress, strUserBalancesQuery);
+                storeResult(key, result);
+            }
+            catch (error2) {
+                console.error('Request to public graph URL failed:', error2);
+                throw new Error(`Could not get user balances for ${accountAddress} on chain ${chainId}`);
+            }
+        }
+    }
+    try {
+        const balances = await promises[key];
+        if (!balances?.vaultShares?.length) {
+            return [];
+        }
+        // Prepare multicall calls
+        const calls = balances.vaultShares.flatMap((share) => {
+            // Normalize token naming by checking which properties exist
+            const token0Address = getTokenAddress(share.vault, 0);
+            const token1Address = getTokenAddress(share.vault, 1);
+            return [
+                (0, multicallUtils_1.encodeTotalAmountsCall)(share.vault.id),
+                (0, multicallUtils_1.encodeTotalSupplyCall)(share.vault.id),
+                (0, multicallUtils_1.encodeDecimalsCall)(token0Address),
+                (0, multicallUtils_1.encodeDecimalsCall)(token1Address),
+            ];
+        });
+        // Execute multicall
+        const results = await (0, multicallUtils_1.multicall)(calls, chainId, jsonProvider);
+        // Process results
+        const processedResults = balances.vaultShares.map((share, index) => {
+            const baseIndex = index * 4;
+            const totalAmounts = (0, multicallUtils_1.decodeTotalAmountsResult)(results[baseIndex], share.vault.id);
+            const totalSupply = (0, multicallUtils_1.decodeTotalSupplyResult)(results[baseIndex + 1], share.vault.id);
+            const token0Address = getTokenAddress(share.vault, 0);
+            const token1Address = getTokenAddress(share.vault, 1);
+            const token0Decimals = (0, multicallUtils_1.decodeDecimalsResult)(results[baseIndex + 2], token0Address);
+            const token1Decimals = (0, multicallUtils_1.decodeDecimalsResult)(results[baseIndex + 3], token1Address);
+            const userBalance = (0, parseBigInt_1.default)(share.vaultShareBalance, types_1.ichiVaultDecimals);
+            if (totalSupply !== 0n) {
+                const amount0 = (userBalance * totalAmounts.total0) / totalSupply;
+                const amount1 = (userBalance * totalAmounts.total1) / totalSupply;
+                if (!raw) {
+                    const userAmounts = {
+                        amount0: (0, formatBigInt_1.default)(amount0, token0Decimals),
+                        amount1: (0, formatBigInt_1.default)(amount1, token1Decimals),
+                        0: (0, formatBigInt_1.default)(amount0, token0Decimals),
+                        1: (0, formatBigInt_1.default)(amount1, token1Decimals),
                     };
-                    if (!!raw) return [3 /*break*/, 7];
-                    return [4 /*yield*/, (0, _totalBalances_1.getTokenDecimals)(vault.tokenA, jsonProvider, chainId)];
-                case 5:
-                    token0Decimals = _b.sent();
-                    return [4 /*yield*/, (0, _totalBalances_1.getTokenDecimals)(vault.tokenB, jsonProvider, chainId)];
-                case 6:
-                    token1Decimals = _b.sent();
-                    userAmounts = {
-                        amount0: (0, formatBigInt_1.default)(userAmountsBN.amount0, token0Decimals),
-                        amount1: (0, formatBigInt_1.default)(userAmountsBN.amount1, token1Decimals),
-                        0: (0, formatBigInt_1.default)(userAmountsBN.amount0, token0Decimals),
-                        1: (0, formatBigInt_1.default)(userAmountsBN.amount1, token1Decimals),
+                    return { vaultAddress: share.vault.id, userAmounts };
+                }
+                else {
+                    const userAmountsBN = {
+                        amount0,
+                        amount1,
+                        0: amount0,
+                        1: amount1,
                     };
-                    return [2 /*return*/, userAmounts];
-                case 7: return [2 /*return*/, userAmountsBN];
-                case 8: return [3 /*break*/, 10];
-                case 9:
-                    if (!raw) {
-                        return [2 /*return*/, {
-                                amount0: '0',
-                                amount1: '0',
-                                0: '0',
-                                1: '0',
-                            }];
-                    }
-                    else {
-                        return [2 /*return*/, {
-                                amount0: ethers_1.BigNumber.from(0),
-                                amount1: ethers_1.BigNumber.from(0),
-                                0: ethers_1.BigNumber.from(0),
-                                1: ethers_1.BigNumber.from(0),
-                            }];
-                    }
-                    _b.label = 10;
-                case 10: return [2 /*return*/];
+                    return { vaultAddress: share.vault.id, userAmounts: userAmountsBN };
+                }
             }
-        });
-    });
-}
-exports.getUserAmounts = getUserAmounts;
-function getAllUserAmounts(accountAddress, jsonProvider, dex, raw) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function () {
-        var chainId, _b, publishedUrl, url, key, strUserBalancesQuery, result, error_2, result, error2_2, balances, calls, signer, results_1, processedResults, error_3;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, (0, vault_1.getChainByProvider)(jsonProvider)];
-                case 1:
-                    chainId = (_c.sent()).chainId;
-                    _b = (0, getGraphUrls_1.getGraphUrls)(chainId, dex, true), publishedUrl = _b.publishedUrl, url = _b.url;
-                    key = "".concat(chainId + accountAddress, "-all-user-amounts");
-                    if (!!Object.prototype.hasOwnProperty.call(promises, key)) return [3 /*break*/, 11];
-                    strUserBalancesQuery = (0, queries_1.getUserBalancesQuery)(chainId, dex);
-                    _c.label = 2;
-                case 2:
-                    _c.trys.push([2, 6, , 11]);
-                    if (!publishedUrl) return [3 /*break*/, 4];
-                    return [4 /*yield*/, sendUserBalancesQueryRequest(publishedUrl, accountAddress, strUserBalancesQuery)];
-                case 3:
-                    result = _c.sent();
-                    storeResult(key, result);
-                    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 = _c.sent();
-                    if (publishedUrl) {
-                        console.error('Request to published graph URL failed:', error_2);
-                    }
-                    _c.label = 7;
-                case 7:
-                    _c.trys.push([7, 9, , 10]);
-                    return [4 /*yield*/, sendUserBalancesQueryRequest(url, accountAddress, strUserBalancesQuery)];
-                case 8:
-                    result = _c.sent();
-                    storeResult(key, result);
-                    return [3 /*break*/, 10];
-                case 9:
-                    error2_2 = _c.sent();
-                    console.error('Request to public graph URL failed:', error2_2);
-                    throw new Error("Could not get user balances for ".concat(accountAddress, " on chain ").concat(chainId));
-                case 10: return [3 /*break*/, 11];
-                case 11:
-                    _c.trys.push([11, 14, , 15]);
-                    return [4 /*yield*/, promises[key]];
-                case 12:
-                    balances = _c.sent();
-                    if (!((_a = balances === null || balances === void 0 ? void 0 : balances.vaultShares) === null || _a === void 0 ? void 0 : _a.length)) {
-                        return [2 /*return*/, []];
-                    }
-                    calls = balances.vaultShares.flatMap(function (share) {
-                        // Normalize token naming by checking which properties exist
-                        var token0Address = getTokenAddress(share.vault, 0);
-                        var token1Address = getTokenAddress(share.vault, 1);
-                        return [
-                            (0, multicallUtils_1.encodeTotalAmountsCall)(share.vault.id),
-                            (0, multicallUtils_1.encodeTotalSupplyCall)(share.vault.id),
-                            (0, multicallUtils_1.encodeDecimalsCall)(token0Address),
-                            (0, multicallUtils_1.encodeDecimalsCall)(token1Address),
-                        ];
-                    });
-                    signer = jsonProvider.getSigner(accountAddress);
-                    return [4 /*yield*/, (0, multicallUtils_1.multicall)(calls, chainId, signer)];
-                case 13:
-                    results_1 = _c.sent();
-                    processedResults = balances.vaultShares.map(function (share, index) {
-                        var baseIndex = index * 4;
-                        var totalAmounts = (0, multicallUtils_1.decodeTotalAmountsResult)(results_1[baseIndex], share.vault.id);
-                        var totalSupply = (0, multicallUtils_1.decodeTotalSupplyResult)(results_1[baseIndex + 1], share.vault.id);
-                        var token0Address = getTokenAddress(share.vault, 0);
-                        var token1Address = getTokenAddress(share.vault, 1);
-                        var token0Decimals = (0, multicallUtils_1.decodeDecimalsResult)(results_1[baseIndex + 2], token0Address);
-                        var token1Decimals = (0, multicallUtils_1.decodeDecimalsResult)(results_1[baseIndex + 3], token1Address);
-                        var userBalance = (0, parseBigInt_1.default)(share.vaultShareBalance, types_1.ichiVaultDecimals);
-                        if (!totalSupply.isZero()) {
-                            var amount0 = userBalance.mul(totalAmounts.total0).div(totalSupply);
-                            var amount1 = userBalance.mul(totalAmounts.total1).div(totalSupply);
-                            if (!raw) {
-                                var userAmounts = {
-                                    amount0: (0, formatBigInt_1.default)(amount0, token0Decimals),
-                                    amount1: (0, formatBigInt_1.default)(amount1, token1Decimals),
-                                    0: (0, formatBigInt_1.default)(amount0, token0Decimals),
-                                    1: (0, formatBigInt_1.default)(amount1, token1Decimals),
-                                };
-                                return { vaultAddress: share.vault.id, userAmounts: userAmounts };
-                            }
-                            else {
-                                var userAmountsBN = {
-                                    amount0: amount0,
-                                    amount1: amount1,
-                                    0: amount0,
-                                    1: amount1,
-                                };
-                                return { vaultAddress: share.vault.id, userAmounts: userAmountsBN };
-                            }
-                        }
-                        else {
-                            return {
-                                vaultAddress: share.vault.id,
-                                userAmounts: !raw
-                                    ? {
-                                        amount0: '0',
-                                        amount1: '0',
-                                        0: '0',
-                                        1: '0',
-                                    }
-                                    : {
-                                        amount0: ethers_1.BigNumber.from(0),
-                                        amount1: ethers_1.BigNumber.from(0),
-                                        0: ethers_1.BigNumber.from(0),
-                                        1: ethers_1.BigNumber.from(0),
-                                    },
-                            };
+            else {
+                return {
+                    vaultAddress: share.vault.id,
+                    userAmounts: !raw
+                        ? {
+                            amount0: '0',
+                            amount1: '0',
+                            0: '0',
+                            1: '0',
                         }
-                    });
-                    return [2 /*return*/, processedResults];
-                case 14:
-                    error_3 = _c.sent();
-                    console.error('Could not get user amounts');
-                    throw error_3;
-                case 15: return [2 /*return*/];
+                        : {
+                            amount0: 0n,
+                            amount1: 0n,
+                            0: 0n,
+                            1: 0n,
+                        },
+                };
             }
         });
-    });
+        return processedResults;
+    }
+    catch (error) {
+        console.error('Could not get user amounts', error);
+        throw error;
+    }
 }
 exports.getAllUserAmounts = getAllUserAmounts;
 //# sourceMappingURL=userBalances.js.map