@alphafi/alphafi-sdk 0.0.49 → 0.0.51

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

@@ -1,9 +1,8 @@
-import { fetchMultiReceipts, cetusPoolMap, bluefinPoolMap, getConf, coinsList, } from "../../index.js";
-import { doubleAssetPoolCoinMap, poolInfo } from "../../common/maps.js";
+import { fetchMultiReceipts, cetusPoolMap, bluefinPoolMap, getConf, } from "../../index.js";
+import { poolInfo } from "../../common/maps.js";
 import { Decimal } from "decimal.js";
 import { getSuiClient } from "../client.js";
 import { SimpleCache } from "../../utils/simpleCache.js";
-import { TickMath } from "@cetusprotocol/cetus-sui-clmm-sdk";
 export function convertReceiptGQLToReceipt(receipts) {
     const res = receipts.map((receipt) => {
         return {
@@ -166,35 +165,6 @@ export async function getReceipts(poolName, address, ignoreCache) {
     }
     return cachedPromise;
 }
-export async function getPoolExchangeRate(poolName, ignoreCache) {
-    let pool;
-    try {
-        pool = await getPool(poolName, ignoreCache);
-        const xTokenSupply = new Decimal(pool.content.fields.xTokenSupply);
-        let tokensInvested = new Decimal(pool.content.fields.tokensInvested);
-        if (poolName == "ALPHA") {
-            tokensInvested = new Decimal(pool.content.fields.alpha_bal);
-        }
-        else if (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(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(0);
-        }
-        const poolExchangeRate = tokensInvested.div(xTokenSupply);
-        return poolExchangeRate;
-    }
-    catch (err) {
-        console.log(`getPoolExchangeRate failed for poolName: ${poolName}, with error ${err}`);
-        throw err;
-    }
-}
 const poolCache = new SimpleCache();
 const poolPromiseCache = new SimpleCache();
 export async function getMultiPool() {
@@ -205,26 +175,37 @@ export async function getMultiPool() {
     const poolIds = pools.map((pool) => {
         return poolInfo[pool].poolId;
     });
-    try {
-        const o = await getSuiClient().multiGetObjects({
-            ids: poolIds,
-            options: {
-                showContent: true,
-            },
-        });
-        for (let i = 0; i < pools.length; i = i + 1) {
-            const poolData = o[i].data;
-            const cacheKey = `pool_${poolInfo[pools[i]].poolId}`;
-            poolCache.set(cacheKey, poolData);
-        }
+    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
     }
-    catch (error) {
-        console.error(`Error getting multiPools - ${error}`);
+    for (const poolIdsBatch of batches) {
+        try {
+            const o = await 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}`);
+        }
     }
 }
 export async function getPool(poolName, ignoreCache) {
     const suiClient = getSuiClient();
-    const cacheKey = `pool_${poolInfo[poolName.toUpperCase()].poolId}`;
+    const cacheKey = `pool_${poolInfo[poolName].poolId}`;
     if (ignoreCache) {
         poolCache.delete(cacheKey);
         poolPromiseCache.delete(cacheKey);
@@ -266,36 +247,135 @@ export async function getPool(poolName, ignoreCache) {
     poolPromiseCache.set(cacheKey, poolPromise);
     return poolPromise;
 }
-const cetusPoolCache = new SimpleCache();
-const cetusPoolPromiseCache = new SimpleCache();
+const parentPoolCache = new SimpleCache();
+const parentPoolPromiseCache = new SimpleCache();
 export async function getMultiParentPool() {
     let pools = Object.keys(poolInfo);
     pools = pools.filter((pool) => {
-        return poolInfo[pool].poolId !== "";
+        return poolInfo[pool].parentPoolId !== "";
     });
-    const poolIds = pools.map((pool) => {
+    const parentPoolIds = pools.map((pool) => {
         return poolInfo[pool].parentPoolId;
     });
-    try {
-        const o = await getSuiClient().multiGetObjects({
-            ids: poolIds,
-            options: {
-                showContent: true,
-            },
-        });
-        for (let i = 0; i < pools.length; i = i + 1) {
-            const poolData = o[i].data;
-            const cacheKey = `pool_${poolInfo[pools[i]].parentPoolId}`;
-            cetusPoolCache.set(cacheKey, poolData);
-        }
+    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
     }
-    catch (e) {
-        console.error(`[getMultiParentPool] Error getting multiPools`);
+    for (const parentPoolIdsBatch of batches) {
+        try {
+            const o = await 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}`);
+        }
     }
 }
 export async function getParentPool(poolName, ignoreCache) {
     const suiClient = getSuiClient();
-    const cacheKey = `pool_${poolName}`;
+    const cacheKey = `parentPool_${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 = poolInfo[poolName]
+                ? poolInfo[poolName].parentPoolId
+                : cetusPoolMap[poolName]
+                    ? cetusPoolMap[poolName]
+                    : 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();
+const cetusPoolPromiseCache = new SimpleCache();
+export async function getMultiCetusPool() {
+    let pools = Object.keys(cetusPoolMap);
+    pools = pools.filter((pool) => {
+        return cetusPoolMap[pool] !== "";
+    });
+    const poolIds = pools.map((pool) => {
+        return 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 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_${cetusPoolMap[pools[i]]}`;
+                cetusPoolCache.set(cacheKey, poolData);
+            }
+        }
+        catch (e) {
+            console.error(`Error getting multiCetusPools`, e);
+        }
+    }
+}
+export async function getCetusPool(poolName, ignoreCache) {
+    const suiClient = getSuiClient();
+    const cacheKey = `cetusPool_${cetusPoolMap[poolName]}`;
     if (ignoreCache) {
         cetusPoolCache.delete(cacheKey);
         cetusPoolPromiseCache.delete(cacheKey);
@@ -313,13 +393,8 @@ export async function getParentPool(poolName, ignoreCache) {
     // If not, create a new promise and cache it
     cetusPoolPromise = (async () => {
         try {
-            const id = poolInfo[poolName]
-                ? poolInfo[poolName].parentPoolId
-                : cetusPoolMap[poolName]
-                    ? cetusPoolMap[poolName]
-                    : bluefinPoolMap[poolName];
             const o = await suiClient.getObject({
-                id: id,
+                id: cetusPoolMap[poolName],
                 options: {
                     showContent: true,
                 },
@@ -329,9 +404,9 @@ export async function getParentPool(poolName, ignoreCache) {
             cetusPoolCache.set(cacheKey, cetusPool);
             return cetusPool;
         }
-        catch (err) {
+        catch (e) {
             console.error(`getCetusPool failed for poolName: ${poolName}`);
-            throw err;
+            return undefined;
         }
         finally {
             // Remove the promise from the cache after it resolves
@@ -352,26 +427,37 @@ export async function getMultiInvestor() {
     const investorIds = pools.map((pool) => {
         return poolInfo[pool].investorId;
     });
-    try {
-        const o = await getSuiClient().multiGetObjects({
-            ids: investorIds,
-            options: {
-                showContent: true,
-            },
-        });
-        for (let i = 0; i < pools.length; i = i + 1) {
-            const investorData = o[i].data;
-            const cacheKey = `investor_${poolInfo[pools[i]].investorId}`;
-            investorCache.set(cacheKey, investorData);
-        }
+    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
     }
-    catch (e) {
-        console.error(`[getMultiInvestor] Error getting multiPools`);
+    for (const investorIdsBatch of batches) {
+        try {
+            const o = await 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}`);
+        }
     }
 }
 export async function getInvestor(poolName, ignoreCache) {
     const suiClient = getSuiClient();
-    const cacheKey = `investor_${poolInfo[poolName.toUpperCase()].investorId}`;
+    const cacheKey = `investor_${poolInfo[poolName].investorId}`;
     if (ignoreCache) {
         investorCache.delete(cacheKey);
         investorPromiseCache.delete(cacheKey);
@@ -390,7 +476,7 @@ export async function getInvestor(poolName, ignoreCache) {
     cetusInvestorPromise = (async () => {
         try {
             const o = await suiClient.getObject({
-                id: poolInfo[poolName.toUpperCase()].investorId,
+                id: poolInfo[poolName].investorId,
                 options: {
                     showContent: true,
                 },
@@ -425,46 +511,6 @@ export async function getInvestor(poolName, ignoreCache) {
     investorPromiseCache.set(cacheKey, cetusInvestorPromise);
     return cetusInvestorPromise;
 }
-export async function fetchVoloExchangeRate() {
-    const apiUrl = "https://open-api.naviprotocol.io/api/volo/stats";
-    const NaviVoloDetails = await 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
-        return data;
-    })
-        .catch((error) => {
-        console.log("failed to fetch Navi-volo details", error);
-        throw error;
-    });
-    return NaviVoloDetails;
-}
-export async function multiGetNaviInvestor(poolNames) {
-    const results = {};
-    const poolInvestorIds = [];
-    for (const poolName of poolNames) {
-        poolInvestorIds.push(poolInfo[poolName.toUpperCase()].investorId);
-    }
-    try {
-        const suiClient = 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;
-    }
-}
 const distributorCache = new SimpleCache();
 const distributorPromiseCache = new SimpleCache();
 export async function getDistributor(ignoreCache) {
@@ -511,83 +557,127 @@ export async function getDistributor(ignoreCache) {
     distributorPromiseCache.set(cacheKey, distributorPromise);
     return distributorPromise;
 }
-export async function getPositionRanges(poolNames = []) {
-    const res = new Map();
-    // Use Promise.all to handle multiple promises in parallel
-    await Promise.all(poolNames.map(async (poolName) => {
-        if (poolName == "ALPHA" ||
-            !["CETUS", "BLUEFIN"].includes(poolInfo[poolName.toString()].parentProtocolName)) {
-            return;
+export async function getPoolExchangeRate(poolName, ignoreCache) {
+    let pool;
+    try {
+        pool = await getPool(poolName, ignoreCache);
+        const xTokenSupply = new Decimal(pool.content.fields.xTokenSupply);
+        let tokensInvested = new Decimal(pool.content.fields.tokensInvested);
+        if (poolName == "ALPHA") {
+            tokensInvested = new Decimal(pool.content.fields.alpha_bal);
         }
-        let investor;
-        if (poolInfo[poolName.toString()].parentProtocolName == "CETUS") {
-            investor = (await getInvestor(poolName, false));
+        else if (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(pool.content.fields.tokensInvested);
         }
-        else {
-            investor = (await getInvestor(poolName, false));
+        // Check for division by zero
+        if (xTokenSupply.eq(0)) {
+            console.error("Division by zero error: tokensInvested is zero.");
+            return new Decimal(0);
         }
-        const coinAName = doubleAssetPoolCoinMap[poolName].coin1;
-        const coinA = coinsList[coinAName];
-        const coinBName = doubleAssetPoolCoinMap[poolName].coin2;
-        const coinB = coinsList[coinBName];
-        if (investor) {
-            const upperBound = 443636;
-            let lowerTick = Number(investor.content.fields.lower_tick);
-            let upperTick = Number(investor.content.fields.upper_tick);
-            if (lowerTick > upperBound) {
-                lowerTick = -~(lowerTick - 1);
+        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();
+const naviVoloExchangeRatePromiseCache = new SimpleCache();
+export 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;
             }
-            if (upperTick > upperBound) {
-                upperTick = -~(upperTick - 1);
+            else {
+                NaviVoloDetails = default_volo_data;
+                return Promise.resolve(default_volo_data);
             }
-            const lowerPrice = TickMath.tickIndexToPrice(lowerTick, coinA.expo, coinB.expo);
-            const upperPrice = TickMath.tickIndexToPrice(upperTick, coinA.expo, coinB.expo);
-            res.set(poolName, {
-                lowerPrice: lowerPrice.toString(),
-                upperPrice: upperPrice.toString(),
-            });
-        }
-    }));
-    return res;
-}
-export async function getPositionRange(ignoreCache) {
-    const res = new Map();
-    for (const poolNameString of Object.keys(poolInfo)) {
-        const poolName = poolNameString;
-        if (poolName == "ALPHA" ||
-            !["CETUS", "BLUEFIN"].includes(poolInfo[poolNameString].parentProtocolName)) {
-            continue;
         }
-        let investor;
-        if (poolInfo[poolNameString].parentProtocolName == "CETUS") {
-            investor = (await getInvestor(poolName, ignoreCache));
+        catch (error) {
+            console.log("error in api", error);
+            NaviVoloDetails = default_volo_data;
+            return Promise.resolve(default_volo_data);
         }
-        else {
-            investor = (await getInvestor(poolName, ignoreCache));
-        }
-        const coinAName = doubleAssetPoolCoinMap[poolName].coin1;
-        const coinA = coinsList[coinAName];
-        const coinBName = doubleAssetPoolCoinMap[poolName].coin2;
-        const coinB = coinsList[coinBName];
-        if (investor) {
-            const upperBound = 443636;
-            let lowerTick = Number(investor.content.fields.lower_tick);
-            let upperTick = Number(investor.content.fields.upper_tick);
-            if (lowerTick > upperBound) {
-                lowerTick = -~(lowerTick - 1);
-            }
-            if (upperTick > upperBound) {
-                upperTick = -~(upperTick - 1);
-            }
-            const lowerPrice = TickMath.tickIndexToPrice(lowerTick, coinA.expo, coinB.expo);
-            const upperPrice = TickMath.tickIndexToPrice(upperTick, coinA.expo, coinB.expo);
-            res.set(poolName, {
-                lowerPrice: lowerPrice.toString(),
-                upperPrice: upperPrice.toString(),
-            });
+    }
+    return NaviVoloDetails;
+}
+export async function multiGetNaviInvestor(poolNames) {
+    const results = {};
+    const poolInvestorIds = [];
+    for (const poolName of poolNames) {
+        poolInvestorIds.push(poolInfo[poolName].investorId);
+    }
+    try {
+        const suiClient = 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;
     }
-    return res;
 }
 /*
 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,