@alphafi/alphafi-sdk 0.0.35 → 0.0.37

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

@@ -1,14 +1,110 @@
-import { cetusPoolMap, poolInfo } from "../../common/maps.js";
-import { SimpleCache } from "../../utils/simpleCache.js";
+import { fetchMultiReceipts, cetusPoolMap, bluefinPoolMap, } from "../../index.js";
+import { poolInfo } from "../../common/maps.js";
 import { ClmmPoolUtil, TickMath } from "@cetusprotocol/cetus-sui-clmm-sdk";
 import BN from "bn.js";
 import { Decimal } from "decimal.js";
 import { getSuiClient } from "../client.js";
-const receiptsCache = new SimpleCache();
-const receiptsPromiseCache = new SimpleCache();
-export async function getReceipts(poolName, address, ignoreCache = false) {
+import { SimpleCache } from "../../utils/simpleCache.js";
+export 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(3600000);
+const receiptsPromiseCache = new SimpleCache(3600000);
+export async function getMultiReceipts(address) {
+    try {
+        const receiptMap = await fetchMultiReceipts(address);
+        for (const pool of Object.keys(poolInfo)) {
+            const cacheKey = `getReceipts-${poolInfo[pool].receiptName}-${address}`;
+            let receipt = [];
+            if (receiptMap.has(poolInfo[pool].receiptName)) {
+                receipt = convertReceiptGQLToReceipt(receiptMap.get(poolInfo[pool].receiptName));
+            }
+            receiptsCache.set(cacheKey, receipt);
+        }
+    }
+    catch (error) {
+        console.error("Error fetching receipts from graphQL:", error);
+        // get receipts individually
+        const pools = Object.keys(poolInfo);
+        const receiptPromises = pools.map((pool) => {
+            return getReceipts(pool, address, true);
+        });
+        const receipts = await Promise.all(receiptPromises);
+        receipts.forEach((receipt, index) => {
+            const cacheKey = `getReceipts-${poolInfo[pools[index]].receiptName}-${address}`;
+            receiptsCache.set(cacheKey, receipt);
+        });
+    }
+}
+export async function getReceipts(poolName, address, ignoreCache) {
     const suiClient = getSuiClient();
-    const receiptsCacheKey = `getReceipts-${poolName}-${address}`;
+    const receiptsCacheKey = `getReceipts-${poolInfo[poolName].receiptName}-${address}`;
     if (ignoreCache) {
         receiptsCache.delete(receiptsCacheKey);
         receiptsPromiseCache.delete(receiptsCacheKey);
@@ -17,16 +113,16 @@ export async function getReceipts(poolName, address, ignoreCache = false) {
     if (cachedResponse) {
         return cachedResponse;
     }
+    //
     const nfts = [];
-    if (poolInfo[poolName].receiptType === "") {
+    if (poolInfo[poolName].receiptType == "") {
         return nfts;
     }
     let cachedPromise = receiptsPromiseCache.get(receiptsCacheKey);
     if (!cachedPromise) {
         cachedPromise = (async () => {
-            // const first_package = conf[CONF_ENV].ALPHA_FIRST_PACKAGE_ID;
+            // const first_package = getConf().ALPHA_FIRST_PACKAGE_ID;
             let currentCursor = null;
-            /* eslint-disable-next-line no-constant-condition */
             while (true) {
                 const paginatedObjects = await suiClient.getOwnedObjects({
                     owner: address,
@@ -36,7 +132,6 @@ export async function getReceipts(poolName, address, ignoreCache = false) {
                         StructType: poolInfo[poolName].receiptType,
                     },
                     options: {
-                        showType: true,
                         showContent: true,
                     },
                 });
@@ -55,6 +150,7 @@ export async function getReceipts(poolName, address, ignoreCache = false) {
                 }
                 else {
                     // No more pages available
+                    // console.log("No more receipts available.");
                     break;
                 }
             }
@@ -62,90 +158,75 @@ export async function getReceipts(poolName, address, ignoreCache = false) {
             receiptsPromiseCache.delete(receiptsCacheKey);
             return nfts;
         })().catch((error) => {
-            // TODO: Jugaad
-            if (poolInfo[poolName].parentProtocolName === "NAVI") {
-                return nfts;
-            }
-            else {
-                receiptsPromiseCache.delete(receiptsCacheKey); // Remove the promise from cache
-                throw 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 poolExchangeRateCache = new SimpleCache();
-export async function getPoolExchangeRate(poolName, ignoreCache = false) {
-    const poolExchangeRateCacheKey = `getPoolExchangeRate-${poolName}`;
-    if (ignoreCache) {
-        poolExchangeRateCache.delete(poolExchangeRateCacheKey);
-    }
-    const cachedResponse = poolExchangeRateCache.get(poolExchangeRateCacheKey);
-    if (cachedResponse) {
-        return cachedResponse;
-    }
+export async function getPoolExchangeRate(poolName, ignoreCache) {
     let pool;
     try {
-        if (poolName === "ALPHA") {
-            pool = await getPool("ALPHA");
-        }
-        else if (poolName === "ALPHA-SUI" ||
-            poolName === "USDT-WUSDC" ||
-            poolName === "USDY-WUSDC" ||
-            poolName === "HASUI-SUI" ||
-            poolName === "WUSDC-SUI" ||
-            poolName === "WETH-WUSDC") {
-            pool = await getPool(poolName);
-        }
-        else {
-            pool = await getPool(poolName);
-        }
+        pool = await getPool(poolName, ignoreCache);
         if (pool) {
             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 undefined;
             }
             const poolExchangeRate = tokensInvested.div(xTokenSupply);
-            poolExchangeRateCache.set(poolExchangeRateCacheKey, poolExchangeRate);
             return poolExchangeRate;
         }
     }
     catch (e) {
-        console.error(`getPoolExchangeRate failed for poolName: ${poolName}`);
+        console.log(`getPoolExchangeRate failed for poolName: ${poolName}, with error ${e}`);
     }
     return undefined;
 }
-export async function getCoinAmountsFromLiquidity(poolName, liquidity) {
-    const cetus_pool = await getCetusPool(poolName);
-    const cetusInvestor = await getCetusInvestor(poolName);
-    const upper_bound = 443636;
-    let lower_tick = Number(cetusInvestor.content.fields.lower_tick);
-    let upper_tick = Number(cetusInvestor.content.fields.upper_tick);
-    if (lower_tick > upper_bound) {
-        lower_tick = -~(lower_tick - 1);
-    }
-    if (upper_tick > upper_bound) {
-        upper_tick = -~(upper_tick - 1);
-    }
-    if (cetus_pool) {
-        const liquidityInt = Math.floor(liquidity);
-        const coin_amounts = ClmmPoolUtil.getCoinAmountFromLiquidity(new BN(`${liquidityInt}`), new BN(cetus_pool.content.fields.current_sqrt_price), TickMath.tickIndexToSqrtPriceX64(lower_tick), TickMath.tickIndexToSqrtPriceX64(upper_tick), true);
-        return [coin_amounts.coinA.toNumber(), coin_amounts.coinB.toNumber()];
+const poolCache = new SimpleCache();
+const poolPromiseCache = new SimpleCache();
+export async function getMultiPool() {
+    let pools = Object.keys(poolInfo);
+    pools = pools.filter((pool) => {
+        return poolInfo[pool].poolId !== "";
+    });
+    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);
+        }
     }
-    else {
-        return [0, 0];
+    catch (e) {
+        console.error(`Error getting multiPools`);
     }
 }
-const poolCache = new SimpleCache();
-const poolPromiseCache = new SimpleCache();
-export async function getPool(poolName, ignoreCache = false) {
+export async function getPool(poolName, ignoreCache) {
+    const suiClient = getSuiClient();
     const cacheKey = `pool_${poolInfo[poolName.toUpperCase()].poolId}`;
     if (ignoreCache) {
         poolCache.delete(cacheKey);
@@ -163,7 +244,6 @@ export async function getPool(poolName, ignoreCache = false) {
     }
     // If not, create a new promise and cache it
     poolPromise = (async () => {
-        const suiClient = getSuiClient();
         try {
             const o = await suiClient.getObject({
                 id: poolInfo[poolName].poolId,
@@ -191,7 +271,33 @@ export async function getPool(poolName, ignoreCache = false) {
 }
 const cetusPoolCache = new SimpleCache();
 const cetusPoolPromiseCache = new SimpleCache();
-export async function getCetusPool(poolName, ignoreCache = false) {
+export async function getMultiParentPool() {
+    let pools = Object.keys(poolInfo);
+    pools = pools.filter((pool) => {
+        return poolInfo[pool].poolId !== "";
+    });
+    const poolIds = 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);
+        }
+    }
+    catch (e) {
+        console.error(`Error getting multiPools`);
+    }
+}
+export async function getParentPool(poolName, ignoreCache) {
+    const suiClient = getSuiClient();
     const cacheKey = `pool_${cetusPoolMap[poolName.toUpperCase()]}`;
     if (ignoreCache) {
         cetusPoolCache.delete(cacheKey);
@@ -210,9 +316,13 @@ export async function getCetusPool(poolName, ignoreCache = false) {
     // If not, create a new promise and cache it
     cetusPoolPromise = (async () => {
         try {
-            const suiClient = getSuiClient();
+            const id = poolInfo[poolName]
+                ? poolInfo[poolName].parentPoolId
+                : cetusPoolMap[poolName]
+                    ? cetusPoolMap[poolName]
+                    : bluefinPoolMap[poolName];
             const o = await suiClient.getObject({
-                id: cetusPoolMap[poolName.toUpperCase()],
+                id: id,
                 options: {
                     showContent: true,
                 },
@@ -224,7 +334,6 @@ export async function getCetusPool(poolName, ignoreCache = false) {
         }
         catch (e) {
             console.error(`getCetusPool failed for poolName: ${poolName}`);
-            console.error(e);
             return undefined;
         }
         finally {
@@ -236,176 +345,147 @@ export async function getCetusPool(poolName, ignoreCache = false) {
     cetusPoolPromiseCache.set(cacheKey, cetusPoolPromise);
     return cetusPoolPromise;
 }
-const cetusInvestorCache = new SimpleCache();
-const cetusInvestorPromiseCache = new SimpleCache();
-export async function getCetusInvestor(poolName, ignoreCache = false) {
+const investorCache = new SimpleCache();
+const investorPromiseCache = new SimpleCache();
+export async function getMultiInvestor() {
+    let pools = Object.keys(poolInfo);
+    pools = pools.filter((pool) => {
+        return poolInfo[pool].investorId !== "";
+    });
+    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);
+        }
+    }
+    catch (e) {
+        console.error(`Error getting multiPools`);
+    }
+}
+export async function getInvestor(poolName, ignoreCache) {
+    const suiClient = getSuiClient();
     const cacheKey = `investor_${poolInfo[poolName.toUpperCase()].investorId}`;
     if (ignoreCache) {
-        cetusInvestorCache.delete(cacheKey);
-        cetusInvestorPromiseCache.delete(cacheKey);
+        investorCache.delete(cacheKey);
+        investorPromiseCache.delete(cacheKey);
     }
     // Check if the investor is already in the cache
-    const cachedInvestor = cetusInvestorCache.get(cacheKey);
+    const cachedInvestor = investorCache.get(cacheKey);
     if (cachedInvestor) {
         return cachedInvestor;
     }
     // Check if there is already a promise in the cache
-    let cetusInvestorPromise = cetusInvestorPromiseCache.get(cacheKey);
+    let cetusInvestorPromise = investorPromiseCache.get(cacheKey);
     if (cetusInvestorPromise) {
         return cetusInvestorPromise;
     }
     // If not, create a new promise and cache it
     cetusInvestorPromise = (async () => {
         try {
-            const suiClient = getSuiClient();
             const o = await suiClient.getObject({
                 id: poolInfo[poolName.toUpperCase()].investorId,
                 options: {
                     showContent: true,
                 },
             });
-            const cetus_investor = o.data;
+            let cetusInvestor;
+            if (poolInfo[poolName].parentProtocolName == "NAVI") {
+                cetusInvestor = o.data;
+            }
+            else if (poolInfo[poolName].parentProtocolName == "BUCKET") {
+                cetusInvestor = o.data;
+            }
+            else if (poolInfo[poolName].parentProtocolName == "BLUEFIN") {
+                cetusInvestor = o.data;
+            }
+            else {
+                cetusInvestor = o.data;
+            }
             // Cache the investor object
-            cetusInvestorCache.set(cacheKey, cetus_investor);
-            return cetus_investor;
+            investorCache.set(cacheKey, cetusInvestor);
+            return cetusInvestor;
         }
         catch (e) {
-            console.error(`getCetusInvestor failed for pool: ${poolName}`);
+            console.error(`getInvestor failed for pool: ${poolName}`);
             return undefined;
         }
         finally {
             // Remove the promise from the cache after it resolves
-            cetusInvestorPromiseCache.delete(cacheKey);
+            investorPromiseCache.delete(cacheKey);
         }
     })();
     // Cache the promise
-    cetusInvestorPromiseCache.set(cacheKey, cetusInvestorPromise);
+    investorPromiseCache.set(cacheKey, cetusInvestorPromise);
     return cetusInvestorPromise;
 }
-const naviInvestorCache = new SimpleCache();
-const naviInvestorPromiseCache = new SimpleCache();
-export async function getNaviInvestor(poolName, ignoreCache = false) {
-    const cacheKey = `investor_${poolInfo[poolName.toUpperCase()].investorId}`;
-    if (ignoreCache) {
-        naviInvestorCache.delete(cacheKey);
-        naviInvestorPromiseCache.delete(cacheKey);
-    }
-    // Check if the investor is already in the cache
-    const cachedInvestor = naviInvestorCache.get(cacheKey);
-    if (cachedInvestor) {
-        return cachedInvestor;
-    }
-    // Check if there is already a promise in the cache
-    let naviInvestorPromise = naviInvestorPromiseCache.get(cacheKey);
-    if (naviInvestorPromise) {
-        return naviInvestorPromise;
-    }
-    // If not, create a new promise and cache it
-    naviInvestorPromise = (async () => {
-        try {
-            const suiClient = getSuiClient();
-            const o = await suiClient.getObject({
-                id: poolInfo[poolName.toUpperCase()].investorId,
-                options: {
-                    showContent: true,
-                },
-            });
-            const navi_investor = o.data;
-            // Cache the investor object
-            naviInvestorCache.set(cacheKey, navi_investor);
-            return navi_investor;
-        }
-        catch (e) {
-            console.error(`getNaviInvestor failed for pool: ${poolName}`);
-            return undefined;
-        }
-        finally {
-            // Remove the promise from the cache after it resolves
-            naviInvestorPromiseCache.delete(cacheKey);
+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}`);
         }
-    })();
-    // Cache the promise
-    naviInvestorPromiseCache.set(cacheKey, naviInvestorPromise);
-    return naviInvestorPromise;
+        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;
 }
-const naviVoloExchangeRateCache = new SimpleCache();
-const naviVoloExchangeRatePromiseCache = new SimpleCache();
-export async function fetchVoloExchangeRate(ignoreCache = false) {
-    const apiUrl = "https://open-api.naviprotocol.io/api/volo/stats";
-    let NaviVoloDetails;
-    if (ignoreCache) {
-        naviVoloExchangeRateCache.clear();
-        naviVoloExchangeRatePromiseCache.delete(apiUrl);
+export async function getCoinAmountsFromLiquidity(poolName, liquidity, ignoreCache) {
+    const clmmPool = await getParentPool(poolName, ignoreCache);
+    const investor = (await getInvestor(poolName, ignoreCache));
+    const upper_bound = 443636;
+    let lower_tick = Number(investor.content.fields.lower_tick);
+    let upper_tick = Number(investor.content.fields.upper_tick);
+    if (lower_tick > upper_bound) {
+        lower_tick = -~(lower_tick - 1);
     }
-    const cachedResponse = naviVoloExchangeRateCache.get(apiUrl);
-    if (cachedResponse) {
-        NaviVoloDetails = cachedResponse;
+    if (upper_tick > upper_bound) {
+        upper_tick = -~(upper_tick - 1);
+    }
+    if (clmmPool) {
+        const liquidityInt = Math.floor(parseFloat(liquidity));
+        const coin_amounts = ClmmPoolUtil.getCoinAmountFromLiquidity(new BN(`${liquidityInt}`), new BN(clmmPool.content.fields.current_sqrt_price), TickMath.tickIndexToSqrtPriceX64(lower_tick), TickMath.tickIndexToSqrtPriceX64(upper_tick), true);
+        return [coin_amounts.coinA.toString(), coin_amounts.coinB.toString()];
     }
     else {
-        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;
+        return ["0", "0"];
     }
-    return NaviVoloDetails;
 }
-export async function multiGetNaviInvestor(poolNames, ignoreCache = false) {
+export async function multiGetNaviInvestor(poolNames) {
     const results = {};
-    const missingPoolInvestorIds = [];
-    const missingPoolNames = [];
+    const poolInvestorIds = [];
     for (const poolName of poolNames) {
-        const cacheKey = `investor_${poolInfo[poolName.toUpperCase()].investorId}`;
-        if (ignoreCache) {
-            naviInvestorCache.delete(cacheKey);
-            naviInvestorPromiseCache.delete(cacheKey);
-        }
-        // Check if the investor is already cached
-        const cachedInvestor = naviInvestorCache.get(cacheKey);
-        if (cachedInvestor) {
-            results[poolName] = cachedInvestor;
-            continue;
-        }
-        else {
-            // Add to missing list if not in cache
-            if (poolInfo[poolName.toUpperCase()].investorId) {
-                missingPoolNames.push(poolName);
-                missingPoolInvestorIds.push(poolInfo[poolName.toUpperCase()].investorId);
-            }
-        }
+        poolInvestorIds.push(poolInfo[poolName.toUpperCase()].investorId);
     }
     try {
         const suiClient = getSuiClient();
         const objects = await suiClient.multiGetObjects({
-            ids: missingPoolInvestorIds,
+            ids: poolInvestorIds,
             options: { showContent: true },
         });
         for (let i = 0; i < objects.length; i++) {
             const investor = objects[i].data;
-            const cacheKey = `investor_${missingPoolInvestorIds[i]}`;
-            naviInvestorCache.set(cacheKey, investor);
-            results[missingPoolNames[i]] = investor;
+            results[poolNames[i]] = investor;
         }
         return results;
     }
     catch (err) {
         //improve
-        console.error("multiGetNaviInvestor failed for poolNames: ", missingPoolNames.join(", "));
+        console.error("multiGetNaviInvestor failed for poolNames: ", poolNames.join(", "));
         throw err;
     }
 }