@alphafi/alphafi-sdk 0.0.107 → 1.0.1

package/dist/cjs/sui-sdk/functions/getReceipts.js

@@ -1,768 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertReceiptGQLToReceipt = convertReceiptGQLToReceipt;
-exports.getMultiReceipts = getMultiReceipts;
-exports.getReceipts = getReceipts;
-exports.getMultiPool = getMultiPool;
-exports.getPool = getPool;
-exports.getMultiParentPool = getMultiParentPool;
-exports.getParentPool = getParentPool;
-exports.getMultiCetusPool = getMultiCetusPool;
-exports.getCetusPool = getCetusPool;
-exports.getMultiInvestor = getMultiInvestor;
-exports.getInvestor = getInvestor;
-exports.getDistributor = getDistributor;
-exports.getPoolExchangeRate = getPoolExchangeRate;
-exports.fetchVoloExchangeRate = fetchVoloExchangeRate;
-exports.multiGetNaviInvestor = multiGetNaviInvestor;
-const index_js_1 = require("../../index.js");
-const maps_js_1 = require("../../common/maps.js");
-const decimal_js_1 = require("decimal.js");
-const client_js_1 = require("../client.js");
-const simpleCache_js_1 = require("../../utils/simpleCache.js");
-/** @deprecated */
-function convertReceiptGQLToReceipt(receipts) {
-    const res = receipts.map((receipt) => {
-        return {
-            objectId: receipt.address,
-            version: receipt.version,
-            digest: receipt.digest,
-            content: {
-                dataType: "moveObject", // Assuming a fixed value as it's not available in ReceiptA
-                type: receipt.contents.type.repr,
-                hasPublicTransfer: receipt.hasPublicTransfer,
-                fields: {
-                    id: { id: receipt.contents.json.id },
-                    image_url: receipt.contents.json.image_url,
-                    last_acc_reward_per_xtoken: {
-                        type: "unknown", // Assuming fixed value
-                        fields: {
-                            contents: receipt.contents.json.last_acc_reward_per_xtoken.contents.map((item) => ({
-                                type: "unknown", // Assuming fixed value
-                                fields: {
-                                    value: item.value,
-                                    key: {
-                                        type: "unknown", // Assuming fixed value
-                                        fields: {
-                                            name: item.key.name,
-                                        },
-                                    },
-                                },
-                            })),
-                        },
-                    },
-                    locked_balance: receipt.contents.json.locked_balance
-                        ? {
-                            type: "unknown", // Assuming fixed value
-                            fields: {
-                                head: receipt.contents.json.locked_balance.head,
-                                id: { id: receipt.contents.json.locked_balance.id },
-                                size: receipt.contents.json.locked_balance.size,
-                                tail: receipt.contents.json.locked_balance.tail,
-                            },
-                        }
-                        : undefined,
-                    name: receipt.contents.json.name,
-                    owner: receipt.contents.json.owner,
-                    pending_rewards: {
-                        type: "unknown", // Assuming fixed value
-                        fields: {
-                            contents: receipt.contents.json.pending_rewards.contents.map((item) => ({
-                                type: "unknown", // Assuming fixed value
-                                fields: {
-                                    key: {
-                                        type: "unknown", // Assuming fixed value
-                                        fields: {
-                                            name: item.key.name,
-                                        },
-                                    },
-                                    value: item.value,
-                                },
-                            })),
-                        },
-                    },
-                    pool_id: receipt.contents.json.pool_id,
-                    xTokenBalance: receipt.contents.json.xTokenBalance,
-                    unlocked_xtokens: receipt.contents.json.unlocked_xtokens ?? undefined,
-                },
-            },
-        };
-    });
-    return res;
-}
-const receiptsCache = new simpleCache_js_1.SimpleCache(3600000);
-const receiptsPromiseCache = new simpleCache_js_1.SimpleCache(3600000);
-/** @deprecated */
-async function getMultiReceipts(address) {
-    try {
-        const receiptMap = await (0, index_js_1.fetchMultiReceipts)(address);
-        for (const pool of Object.keys(maps_js_1.poolInfo)) {
-            const cacheKey = `getReceipts-${maps_js_1.poolInfo[pool].receiptName}-${address}`;
-            let receipt = [];
-            if (pool === "ALPHALEND-LOOP-SUI-STSUI" &&
-                receiptMap.has("AlphaFi-Navi SUI-STSUI Receipt")) {
-                receipt = convertReceiptGQLToReceipt(receiptMap.get("AlphaFi-Navi SUI-STSUI Receipt"));
-            }
-            else if (receiptMap.has(maps_js_1.poolInfo[pool].receiptName)) {
-                receipt = convertReceiptGQLToReceipt(receiptMap.get(maps_js_1.poolInfo[pool].receiptName));
-            }
-            receiptsCache.set(cacheKey, receipt);
-        }
-    }
-    catch (error) {
-        console.error("Error fetching receipts from graphQL:", error);
-        // get receipts individually
-        const pools = Object.keys(maps_js_1.poolInfo);
-        const receiptPromises = pools.map((pool) => {
-            return getReceipts(pool, address, true);
-        });
-        const receipts = await Promise.all(receiptPromises);
-        receipts.forEach((receipt, index) => {
-            const cacheKey = `getReceipts-${maps_js_1.poolInfo[pools[index]].receiptName}-${address}`;
-            receiptsCache.set(cacheKey, receipt);
-        });
-    }
-}
-/** @deprecated */
-async function getReceipts(poolName, address, ignoreCache) {
-    const suiClient = (0, client_js_1.getSuiClient)();
-    const receiptsCacheKey = `getReceipts-${maps_js_1.poolInfo[poolName].receiptName}-${address}`;
-    if (ignoreCache) {
-        receiptsCache.delete(receiptsCacheKey);
-        receiptsPromiseCache.delete(receiptsCacheKey);
-    }
-    const cachedResponse = receiptsCache.get(receiptsCacheKey);
-    if (cachedResponse) {
-        return cachedResponse;
-    }
-    //
-    const nfts = [];
-    if (maps_js_1.poolInfo[poolName].receiptType == "") {
-        return nfts;
-    }
-    let cachedPromise = receiptsPromiseCache.get(receiptsCacheKey);
-    if (!cachedPromise) {
-        cachedPromise = (async () => {
-            // const first_package = getConf().ALPHA_FIRST_PACKAGE_ID;
-            let currentCursor = null;
-            while (true) {
-                const paginatedObjects = await suiClient.getOwnedObjects({
-                    owner: address,
-                    cursor: currentCursor,
-                    filter: {
-                        // StructType: `${first_package}::${module}::Receipt`,
-                        StructType: maps_js_1.poolInfo[poolName].receiptType,
-                    },
-                    options: {
-                        showContent: true,
-                    },
-                });
-                // Traverse the current page data and push to coins array
-                paginatedObjects.data.forEach((obj) => {
-                    const o = obj.data;
-                    if (o) {
-                        if (maps_js_1.poolInfo[poolName].receiptName === o.content.fields.name ||
-                            (poolName === "ALPHALEND-LOOP-SUI-STSUI" &&
-                                o.content.fields.name === "AlphaFi-Navi SUI-STSUI Receipt")) {
-                            nfts.push(o);
-                        }
-                    }
-                });
-                // Check if there's a next page
-                if (paginatedObjects.hasNextPage && paginatedObjects.nextCursor) {
-                    currentCursor = paginatedObjects.nextCursor;
-                }
-                else {
-                    // No more pages available
-                    // console.log("No more receipts available.");
-                    break;
-                }
-            }
-            receiptsCache.set(receiptsCacheKey, nfts);
-            receiptsPromiseCache.delete(receiptsCacheKey);
-            return nfts;
-        })().catch((error) => {
-            receiptsPromiseCache.delete(receiptsCacheKey); // Remove the promise from cache
-            throw error;
-        });
-        // const data = await cachedPromise;
-        // console.log("received cached data", data);
-        receiptsPromiseCache.set(receiptsCacheKey, cachedPromise);
-    }
-    return cachedPromise;
-}
-const poolCache = new simpleCache_js_1.SimpleCache();
-const poolPromiseCache = new simpleCache_js_1.SimpleCache();
-/** @deprecated */
-async function getMultiPool() {
-    let pools = Object.keys(maps_js_1.poolInfo);
-    pools = pools.filter((pool) => {
-        return maps_js_1.poolInfo[pool].poolId !== "";
-    });
-    const poolIds = pools.map((pool) => {
-        return maps_js_1.poolInfo[pool].poolId;
-    });
-    const batchSize = 49; // Set the desired batch size
-    // Create an array to hold the batches
-    const batches = [];
-    //const batches = [];
-    // Loop through the entries array and create batches
-    for (let i = 0; i < poolIds.length; i += batchSize) {
-        const batchEntries = poolIds.slice(i, i + batchSize);
-        batches.push(batchEntries); // Convert to object before pushing
-    }
-    for (const poolIdsBatch of batches) {
-        try {
-            const o = await (0, client_js_1.getSuiClient)().multiGetObjects({
-                ids: poolIdsBatch,
-                options: {
-                    showContent: true,
-                },
-            });
-            for (let i = 0; i < poolIdsBatch.length; i = i + 1) {
-                const poolData = o[i].data;
-                const cacheKey = `pool_${poolIdsBatch[i]}`;
-                poolCache.set(cacheKey, poolData);
-            }
-        }
-        catch (error) {
-            console.error(`Error getting multiPools - ${error}`);
-        }
-    }
-}
-/** @deprecated */
-async function getPool(poolName, ignoreCache) {
-    const suiClient = (0, client_js_1.getSuiClient)();
-    const cacheKey = `pool_${maps_js_1.poolInfo[poolName].poolId}`;
-    if (ignoreCache) {
-        poolCache.delete(cacheKey);
-        poolPromiseCache.delete(cacheKey);
-    }
-    // Check if the pool is already in the cache
-    const cachedPool = poolCache.get(cacheKey);
-    if (cachedPool) {
-        return cachedPool;
-    }
-    // Check if there is already a promise in the cache
-    let poolPromise = poolPromiseCache.get(cacheKey);
-    if (poolPromise) {
-        return poolPromise;
-    }
-    // If not, create a new promise and cache it
-    poolPromise = (async () => {
-        try {
-            const o = await suiClient.getObject({
-                id: maps_js_1.poolInfo[poolName].poolId,
-                options: {
-                    showContent: true,
-                },
-            });
-            const poolData = poolName === "ALPHA" ? o.data : o.data;
-            // Cache the pool object
-            poolCache.set(cacheKey, poolData);
-            return poolData;
-        }
-        catch (err) {
-            console.error(`Error in getPool; poolName => ${poolName}`);
-            throw err;
-        }
-        finally {
-            // Remove the promise from the cache after it resolves
-            poolPromiseCache.delete(cacheKey);
-        }
-    })();
-    // Cache the promise
-    poolPromiseCache.set(cacheKey, poolPromise);
-    return poolPromise;
-}
-const parentPoolCache = new simpleCache_js_1.SimpleCache();
-const parentPoolPromiseCache = new simpleCache_js_1.SimpleCache();
-/** @deprecated */
-async function getMultiParentPool() {
-    let pools = Object.keys(maps_js_1.poolInfo);
-    pools = pools.filter((pool) => {
-        return maps_js_1.poolInfo[pool].parentPoolId !== "";
-    });
-    const parentPoolIds = pools.map((pool) => {
-        return maps_js_1.poolInfo[pool].parentPoolId;
-    });
-    const poolsSet = new Set(parentPoolIds);
-    const poolIds = [...poolsSet];
-    const batchSize = 49;
-    // Create an array to hold the batches
-    const batches = [];
-    //const batches = [];
-    // Loop through the entries array and create batches
-    for (let i = 0; i < poolIds.length; i += batchSize) {
-        const batchEntries = poolIds.slice(i, i + batchSize);
-        batches.push(batchEntries); // Convert to object before pushing
-    }
-    for (const parentPoolIdsBatch of batches) {
-        try {
-            const o = await (0, client_js_1.getSuiClient)().multiGetObjects({
-                ids: parentPoolIdsBatch,
-                options: {
-                    showContent: true,
-                },
-            });
-            for (let i = 0; i < parentPoolIdsBatch.length; i = i + 1) {
-                const parentPoolData = o[i].data;
-                const cacheKey = `parentPool_${parentPoolIdsBatch[i]}`;
-                parentPoolCache.set(cacheKey, parentPoolData);
-            }
-        }
-        catch (error) {
-            console.error(`Error getting multiParentPools - ${error}`);
-        }
-    }
-}
-/** @deprecated */
-async function getParentPool(poolName, ignoreCache) {
-    const suiClient = (0, client_js_1.getSuiClient)();
-    const cacheKey = `parentPool_${maps_js_1.poolInfo[poolName].parentPoolId}`;
-    if (ignoreCache) {
-        parentPoolCache.delete(cacheKey);
-        parentPoolPromiseCache.delete(cacheKey);
-    }
-    // Check if the pool is already in the cache
-    const cachedPool = parentPoolCache.get(cacheKey);
-    if (cachedPool) {
-        return cachedPool;
-    }
-    // Check if there is already a promise in the cache
-    let parentPoolPromise = parentPoolPromiseCache.get(cacheKey);
-    if (parentPoolPromise) {
-        return parentPoolPromise;
-    }
-    // If not, create a new promise and cache it
-    parentPoolPromise = (async () => {
-        try {
-            const id = maps_js_1.poolInfo[poolName]
-                ? maps_js_1.poolInfo[poolName].parentPoolId
-                : index_js_1.cetusPoolMap[poolName]
-                    ? index_js_1.cetusPoolMap[poolName]
-                    : index_js_1.bluefinPoolMap[poolName];
-            const o = await suiClient.getObject({
-                id: id,
-                options: {
-                    showContent: true,
-                },
-            });
-            const parentPool = o.data;
-            // Cache the pool object
-            parentPoolCache.set(cacheKey, parentPool);
-            return parentPool;
-        }
-        catch (err) {
-            console.error(`getParentPool failed for poolName: ${poolName}`);
-            throw err;
-        }
-        finally {
-            // Remove the promise from the cache after it resolves
-            parentPoolPromiseCache.delete(cacheKey);
-        }
-    })();
-    // Cache the promise
-    parentPoolPromiseCache.set(cacheKey, parentPoolPromise);
-    return parentPoolPromise;
-}
-const cetusPoolCache = new simpleCache_js_1.SimpleCache();
-const cetusPoolPromiseCache = new simpleCache_js_1.SimpleCache();
-/** @deprecated */
-async function getMultiCetusPool() {
-    let pools = Object.keys(index_js_1.cetusPoolMap);
-    pools = pools.filter((pool) => {
-        return index_js_1.cetusPoolMap[pool] !== "";
-    });
-    const poolIds = pools.map((pool) => {
-        return index_js_1.cetusPoolMap[pool];
-    });
-    const batchSize = 49;
-    // Create an array to hold the batches
-    const batches = [];
-    // Loop through the entries array and create batches
-    for (let i = 0; i < poolIds.length; i += batchSize) {
-        const batchEntries = poolIds.slice(i, i + batchSize);
-        batches.push(batchEntries); // Convert to object before pushing
-    }
-    for (const cetusPoolIdsBatch of batches) {
-        try {
-            const o = await (0, client_js_1.getSuiClient)().multiGetObjects({
-                ids: cetusPoolIdsBatch,
-                options: {
-                    showContent: true,
-                },
-            });
-            for (let i = 0; i < pools.length; i = i + 1) {
-                const poolData = o[i].data;
-                const cacheKey = `cetusPool_${index_js_1.cetusPoolMap[pools[i]]}`;
-                cetusPoolCache.set(cacheKey, poolData);
-            }
-        }
-        catch (e) {
-            console.error(`Error getting multiCetusPools`, e);
-        }
-    }
-}
-/** @deprecated */
-async function getCetusPool(poolName, ignoreCache) {
-    const suiClient = (0, client_js_1.getSuiClient)();
-    const cacheKey = `cetusPool_${index_js_1.cetusPoolMap[poolName]}`;
-    if (ignoreCache) {
-        cetusPoolCache.delete(cacheKey);
-        cetusPoolPromiseCache.delete(cacheKey);
-    }
-    // Check if the pool is already in the cache
-    const cachedPool = cetusPoolCache.get(cacheKey);
-    if (cachedPool) {
-        return cachedPool;
-    }
-    // Check if there is already a promise in the cache
-    let cetusPoolPromise = cetusPoolPromiseCache.get(cacheKey);
-    if (cetusPoolPromise) {
-        return cetusPoolPromise;
-    }
-    // If not, create a new promise and cache it
-    cetusPoolPromise = (async () => {
-        try {
-            const o = await suiClient.getObject({
-                id: index_js_1.cetusPoolMap[poolName],
-                options: {
-                    showContent: true,
-                },
-            });
-            const cetusPool = o.data;
-            // Cache the pool object
-            cetusPoolCache.set(cacheKey, cetusPool);
-            return cetusPool;
-        }
-        catch {
-            console.error(`getCetusPool failed for poolName: ${poolName}`);
-            return undefined;
-        }
-        finally {
-            // Remove the promise from the cache after it resolves
-            cetusPoolPromiseCache.delete(cacheKey);
-        }
-    })();
-    // Cache the promise
-    cetusPoolPromiseCache.set(cacheKey, cetusPoolPromise);
-    return cetusPoolPromise;
-}
-const investorCache = new simpleCache_js_1.SimpleCache();
-const investorPromiseCache = new simpleCache_js_1.SimpleCache();
-/** @deprecated */
-async function getMultiInvestor() {
-    let pools = Object.keys(maps_js_1.poolInfo);
-    pools = pools.filter((pool) => {
-        return maps_js_1.poolInfo[pool].investorId !== "";
-    });
-    const investorIds = pools.map((pool) => {
-        return maps_js_1.poolInfo[pool].investorId;
-    });
-    const batchSize = 49;
-    // Create an array to hold the batches
-    const batches = [];
-    //const batches = [];
-    // Loop through the entries array and create batches
-    for (let i = 0; i < investorIds.length; i += batchSize) {
-        const batchEntries = investorIds.slice(i, i + batchSize);
-        batches.push(batchEntries); // Convert to object before pushing
-    }
-    for (const investorIdsBatch of batches) {
-        try {
-            const o = await (0, client_js_1.getSuiClient)().multiGetObjects({
-                ids: investorIdsBatch,
-                options: {
-                    showContent: true,
-                },
-            });
-            for (let i = 0; i < investorIdsBatch.length; i = i + 1) {
-                const investorData = o[i].data;
-                const cacheKey = `investor_${investorIdsBatch[i]}`;
-                investorCache.set(cacheKey, investorData);
-            }
-        }
-        catch (error) {
-            console.error(`Error getting multiInvestor - ${error}`);
-        }
-    }
-}
-/** @deprecated */
-async function getInvestor(poolName, ignoreCache) {
-    const suiClient = (0, client_js_1.getSuiClient)();
-    const cacheKey = `investor_${maps_js_1.poolInfo[poolName].investorId}`;
-    if (ignoreCache) {
-        investorCache.delete(cacheKey);
-        investorPromiseCache.delete(cacheKey);
-    }
-    // Check if the investor is already in the cache
-    const cachedInvestor = investorCache.get(cacheKey);
-    if (cachedInvestor) {
-        return cachedInvestor;
-    }
-    // Check if there is already a promise in the cache
-    let cetusInvestorPromise = investorPromiseCache.get(cacheKey);
-    if (cetusInvestorPromise) {
-        return cetusInvestorPromise;
-    }
-    // If not, create a new promise and cache it
-    cetusInvestorPromise = (async () => {
-        try {
-            const o = await suiClient.getObject({
-                id: maps_js_1.poolInfo[poolName].investorId,
-                options: {
-                    showContent: true,
-                },
-            });
-            let cetusInvestor;
-            if (maps_js_1.poolInfo[poolName].parentProtocolName == "NAVI") {
-                cetusInvestor = o.data;
-            }
-            else if (maps_js_1.poolInfo[poolName].parentProtocolName == "BUCKET") {
-                cetusInvestor = o.data;
-            }
-            else if (maps_js_1.poolInfo[poolName].parentProtocolName == "BLUEFIN") {
-                if (maps_js_1.poolInfo[poolName].strategyType === "LEVERAGE-YIELD-FARMING") {
-                    const pool = (await getPool(poolName, ignoreCache));
-                    let lyfInvestorTemp = pool.content.fields.investor;
-                    let lyfInvestor = {
-                        content: {
-                            fields: {
-                                ...lyfInvestorTemp.fields,
-                            },
-                        },
-                    };
-                    cetusInvestor = lyfInvestor;
-                }
-                else {
-                    cetusInvestor = o.data;
-                }
-            }
-            else if (maps_js_1.poolInfo[poolName].parentProtocolName == "ALPHALEND") {
-                cetusInvestor = o.data;
-            }
-            else if (maps_js_1.poolInfo[poolName].parentProtocolName == "CETUS") {
-                cetusInvestor = o.data;
-            }
-            else {
-                throw new Error(`Unexpected parent protocol: ${maps_js_1.poolInfo[poolName].parentProtocolName}`);
-            }
-            // Cache the investor object
-            investorCache.set(cacheKey, cetusInvestor);
-            return cetusInvestor;
-        }
-        catch (err) {
-            console.error(`getInvestor failed for pool: ${poolName}`);
-            throw err;
-        }
-        finally {
-            // Remove the promise from the cache after it resolves
-            investorPromiseCache.delete(cacheKey);
-        }
-    })();
-    // Cache the promise
-    investorPromiseCache.set(cacheKey, cetusInvestorPromise);
-    return cetusInvestorPromise;
-}
-const distributorCache = new simpleCache_js_1.SimpleCache();
-const distributorPromiseCache = new simpleCache_js_1.SimpleCache();
-/** @deprecated */
-async function getDistributor(ignoreCache) {
-    const suiClient = (0, client_js_1.getSuiClient)();
-    const cacheKey = `distributor_${(0, index_js_1.getConf)().ALPHA_DISTRIBUTOR}`;
-    if (ignoreCache) {
-        distributorCache.delete(cacheKey);
-        distributorPromiseCache.delete(cacheKey);
-    }
-    // Check if the distributor is already in the cache
-    const cachedDistributor = distributorCache.get(cacheKey);
-    if (cachedDistributor) {
-        return cachedDistributor;
-    }
-    // Check if there is already a promise in the cache
-    let distributorPromise = distributorPromiseCache.get(cacheKey);
-    if (distributorPromise) {
-        return distributorPromise;
-    }
-    // If not, create a new promise and cache it
-    distributorPromise = (async () => {
-        try {
-            const o = await suiClient.getObject({
-                id: (0, index_js_1.getConf)().ALPHA_DISTRIBUTOR,
-                options: {
-                    showContent: true,
-                },
-            });
-            const distributor = o.data;
-            // Cache the distributor object
-            distributorCache.set(cacheKey, distributor);
-            return distributor;
-        }
-        catch {
-            console.error(`getDistributor failed`);
-            return undefined;
-        }
-        finally {
-            // Remove the promise from the cache after it resolves
-            distributorPromiseCache.delete(cacheKey);
-        }
-    })();
-    // Cache the promise
-    distributorPromiseCache.set(cacheKey, distributorPromise);
-    return distributorPromise;
-}
-/** @deprecated */
-async function getPoolExchangeRate(poolName, ignoreCache) {
-    let pool;
-    let xTokenSupply = new decimal_js_1.Decimal(0);
-    let tokensInvested = new decimal_js_1.Decimal(0);
-    try {
-        if (poolName.toString().includes("ALPHALEND-SLUSH")) {
-            const o = await (0, client_js_1.getSuiClient)().getObject({
-                id: maps_js_1.poolInfo[poolName].poolId,
-                options: {
-                    showContent: true,
-                },
-            });
-            if (!o.data) {
-                throw new Error(`couldnt fetch pool object for pool: ${poolName}`);
-            }
-            tokensInvested = new decimal_js_1.Decimal(o.data.content.fields.tokensInvested);
-            xTokenSupply = new decimal_js_1.Decimal(o.data.content?.fields.xTokenSupply.fields.value);
-        }
-        else {
-            pool = await getPool(poolName, ignoreCache);
-            if (poolName.toString().includes("-FUNGIBLE-") &&
-                "treasury_cap" in pool.content.fields) {
-                xTokenSupply = new decimal_js_1.Decimal(pool.content.fields.treasury_cap.fields.total_supply.fields.value);
-            }
-            else {
-                xTokenSupply = new decimal_js_1.Decimal(pool.content.fields.xTokenSupply);
-            }
-            tokensInvested = new decimal_js_1.Decimal(pool.content.fields.tokensInvested);
-            if (poolName == "ALPHA") {
-                tokensInvested = new decimal_js_1.Decimal(pool.content.fields.tokensInvested);
-            }
-            else if (maps_js_1.poolInfo[poolName].parentProtocolName == "CETUS") {
-                const investor = (await getInvestor(poolName, ignoreCache));
-                if (!investor) {
-                    throw new Error(`couldnt fetch investor object for pool: ${poolName}`);
-                }
-                tokensInvested = new decimal_js_1.Decimal(pool.content.fields.tokensInvested);
-            }
-        }
-        // Check for division by zero
-        if (xTokenSupply.eq(0)) {
-            console.error("Division by zero error: tokensInvested is zero.");
-            return new decimal_js_1.Decimal(0);
-        }
-        const poolExchangeRate = tokensInvested.div(xTokenSupply);
-        return poolExchangeRate;
-    }
-    catch (err) {
-        console.log(`getPoolExchangeRate failed for poolName: ${poolName}, with error ${err}`);
-        throw err;
-    }
-}
-const naviVoloExchangeRateCache = new simpleCache_js_1.SimpleCache();
-const naviVoloExchangeRatePromiseCache = new simpleCache_js_1.SimpleCache();
-/** @deprecated */
-async function fetchVoloExchangeRate(ignoreCache) {
-    const apiUrl = "https://open-api.naviprotocol.io/api/volo/stats";
-    let NaviVoloDetails;
-    if (ignoreCache) {
-        naviVoloExchangeRateCache.clear();
-        naviVoloExchangeRatePromiseCache.delete(apiUrl);
-    }
-    const cachedResponse = naviVoloExchangeRateCache.get(apiUrl);
-    if (cachedResponse) {
-        NaviVoloDetails = cachedResponse;
-    }
-    else {
-        const default_volo_data = {
-            data: {
-                operatorBalance: "",
-                collectableFee: "",
-                pendingStakes: "",
-                poolTotalRewards: "0",
-                unstakeTicketSupply: "",
-                totalStaked: "",
-                activeStake: "",
-                calcTotalRewards: "",
-                currentEpoch: "",
-                validators: {},
-                exchangeRate: (1 / 0.973).toString(),
-                totalSupply: "",
-                apy: "",
-                sortedValidators: [""],
-                maxInstantUnstake: "",
-                maxNoFeeUnstake: "",
-            },
-            code: 0,
-        };
-        try {
-            let cachedPromise = naviVoloExchangeRatePromiseCache.get(apiUrl);
-            if (!cachedPromise) {
-                cachedPromise = fetch(apiUrl)
-                    .then(async (response) => {
-                    if (!response.ok) {
-                        throw new Error(`HTTP error! status: ${response.status}`);
-                    }
-                    const data = (await response.json()); // Parse the JSON response
-                    naviVoloExchangeRateCache.set(apiUrl, data); // Cache the response
-                    naviVoloExchangeRatePromiseCache.delete(apiUrl); // Remove the promise from the cache
-                    return data;
-                })
-                    .catch((error) => {
-                    naviVoloExchangeRatePromiseCache.delete(apiUrl); // Ensure the promise is removed on error
-                    throw error;
-                });
-                naviVoloExchangeRatePromiseCache.set(apiUrl, cachedPromise);
-                NaviVoloDetails = await cachedPromise;
-                return cachedPromise;
-            }
-            else {
-                NaviVoloDetails = default_volo_data;
-                return Promise.resolve(default_volo_data);
-            }
-        }
-        catch (error) {
-            console.log("error in api", error);
-            NaviVoloDetails = default_volo_data;
-            return Promise.resolve(default_volo_data);
-        }
-    }
-    return NaviVoloDetails;
-}
-/** @deprecated */
-async function multiGetNaviInvestor(poolNames) {
-    const results = {};
-    const poolInvestorIds = [];
-    for (const poolName of poolNames) {
-        poolInvestorIds.push(maps_js_1.poolInfo[poolName].investorId);
-    }
-    try {
-        const suiClient = (0, client_js_1.getSuiClient)();
-        const objects = await suiClient.multiGetObjects({
-            ids: poolInvestorIds,
-            options: { showContent: true },
-        });
-        for (let i = 0; i < objects.length; i++) {
-            const investor = objects[i].data;
-            results[poolNames[i]] = investor;
-        }
-        return results;
-    }
-    catch (err) {
-        //improve
-        console.error("multiGetNaviInvestor failed for poolNames: ", poolNames.join(", "));
-        throw err;
-    }
-}
-/*
-for the missing pools, add a promise, each of those promises waits for there respective object from a map, that map is populated all at once,
-problem with concurrency
-*/
-// ask how to deal with this kind of probem with high concurrency anf throughput
-//# sourceMappingURL=getReceipts.js.map