@alphafi/alphafi-sdk 0.0.2

package/src/functions.ts

@@ -0,0 +1,299 @@
+import BN from "bn.js";
+import { ClmmPoolUtil, TickMath } from "@cetusprotocol/cetus-sui-clmm-sdk";
+import { PaginatedObjectsResponse, SuiClient } from "@mysten/sui/client";
+import Decimal from "decimal.js";
+import { cetusPoolMap, poolInfo } from "./common/maps";
+import {
+  CetusInvestor,
+  CetusPoolType,
+  CoinAmounts,
+  PoolName,
+  Receipt,
+  SimpleCache,
+} from "./common/types";
+import { getPool } from "./portfolioAmount";
+
+const receiptsCache = new SimpleCache<Receipt[]>();
+const receiptsPromiseCache = new SimpleCache<Promise<Receipt[]>>();
+export async function getReceipts(
+  poolName: string,
+  options: {
+    address: string;
+    suiClient: SuiClient;
+  },
+  ignoreCache: boolean = false,
+): Promise<Receipt[]> {
+  const receiptsCacheKey = `getReceipts-${poolName}-${options.address}`;
+  if (ignoreCache) {
+    receiptsCache.delete(receiptsCacheKey);
+    receiptsPromiseCache.delete(receiptsCacheKey);
+  }
+  const cachedResponse = receiptsCache.get(receiptsCacheKey);
+  if (cachedResponse) {
+    return cachedResponse;
+  }
+
+  const nfts: Receipt[] = [];
+
+  let cachedPromise = receiptsPromiseCache.get(receiptsCacheKey);
+  if (!cachedPromise) {
+    cachedPromise = (async (): Promise<Receipt[]> => {
+      // const first_package = conf[CONF_ENV].ALPHA_FIRST_PACKAGE_ID;
+      let currentCursor: string | null | undefined = null;
+      /* eslint-disable-next-line no-constant-condition */
+      while (true) {
+        const paginatedObjects: PaginatedObjectsResponse =
+          await options.suiClient.getOwnedObjects({
+            owner: options.address,
+            cursor: currentCursor,
+            filter: {
+              // StructType: `${first_package}::${module}::Receipt`,
+              StructType: poolInfo[poolName].receiptType,
+            },
+            options: {
+              showType: true,
+              showContent: true,
+            },
+          });
+        // Traverse the current page data and push to coins array
+
+        paginatedObjects.data.forEach((obj) => {
+          const o = obj.data as Receipt;
+          if (o) {
+            if (poolInfo[poolName].receiptName === o.content.fields.name) {
+              nfts.push(o);
+            }
+          }
+        });
+
+        // Check if there's a next page
+        if (paginatedObjects.hasNextPage && paginatedObjects.nextCursor) {
+          currentCursor = paginatedObjects.nextCursor;
+        } else {
+          // No more pages available
+          break;
+        }
+      }
+      receiptsCache.set(receiptsCacheKey, nfts);
+      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.set(receiptsCacheKey, cachedPromise);
+  }
+  return cachedPromise;
+}
+
+const poolExchangeRateCache = new SimpleCache<Decimal>();
+
+export async function getPoolExchangeRate(
+  poolName: PoolName,
+  options: { suiClient: SuiClient },
+  ignoreCache: boolean = false,
+): Promise<Decimal | undefined> {
+  const poolExchangeRateCacheKey = `getPoolExchangeRate-${poolName}`;
+  if (ignoreCache) {
+    poolExchangeRateCache.delete(poolExchangeRateCacheKey);
+  }
+  const cachedResponse = poolExchangeRateCache.get(poolExchangeRateCacheKey);
+  if (cachedResponse) {
+    return cachedResponse;
+  }
+
+  let pool = undefined;
+  try {
+    if (poolName === "ALPHA") {
+      pool = await getPool("ALPHA", options);
+    } else if (
+      poolName === "ALPHA-SUI" ||
+      poolName === "USDT-USDC" ||
+      poolName === "USDY-USDC" ||
+      poolName === "HASUI-SUI" ||
+      poolName === "USDC-SUI" ||
+      poolName === "WETH-USDC"
+    ) {
+      pool = await getPool(poolName, options);
+    } else {
+      pool = await getPool(poolName, options);
+    }
+    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);
+      }
+
+      // 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}`);
+  }
+
+  return undefined;
+}
+
+export async function getCoinAmountsFromLiquidity(
+  poolName: PoolName,
+  liquidity: number,
+  options: { suiClient: SuiClient },
+): Promise<[number, number]> {
+  const cetus_pool = await getCetusPool(poolName, options);
+  const cetusInvestor = await getCetusInvestor(poolName, options);
+
+  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: CoinAmounts = 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()];
+  } else {
+    return [0, 0];
+  }
+}
+
+const cetusPoolCache = new SimpleCache<CetusPoolType>();
+const cetusPoolPromiseCache = new SimpleCache<
+  Promise<CetusPoolType | undefined>
+>();
+
+export async function getCetusPool(
+  poolName: string,
+  options: {
+    suiClient: SuiClient;
+  },
+  ignoreCache: boolean = false,
+): Promise<CetusPoolType | undefined> {
+  const cacheKey = `pool_${cetusPoolMap[poolName.toUpperCase()]}`;
+  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 options.suiClient.getObject({
+        id: cetusPoolMap[poolName.toUpperCase()],
+        options: {
+          showContent: true,
+        },
+      });
+      const cetusPool = o.data as CetusPoolType;
+
+      // Cache the pool object
+      cetusPoolCache.set(cacheKey, cetusPool);
+      return cetusPool;
+    } catch (e) {
+      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 cetusInvestorCache = new SimpleCache<CetusInvestor>();
+const cetusInvestorPromiseCache = new SimpleCache<
+  Promise<CetusInvestor | undefined>
+>();
+
+export async function getCetusInvestor(
+  poolName: PoolName,
+  options: {
+    suiClient: SuiClient;
+  },
+  ignoreCache: boolean = false,
+): Promise<CetusInvestor | undefined> {
+  const cacheKey = `investor_${poolInfo[poolName.toUpperCase()].investorId}`;
+  if (ignoreCache) {
+    cetusInvestorCache.delete(cacheKey);
+    cetusInvestorPromiseCache.delete(cacheKey);
+  }
+  // Check if the investor is already in the cache
+  const cachedInvestor = cetusInvestorCache.get(cacheKey);
+  if (cachedInvestor) {
+    return cachedInvestor;
+  }
+
+  // Check if there is already a promise in the cache
+  let cetusInvestorPromise = cetusInvestorPromiseCache.get(cacheKey);
+  if (cetusInvestorPromise) {
+    return cetusInvestorPromise;
+  }
+
+  // If not, create a new promise and cache it
+  cetusInvestorPromise = (async () => {
+    try {
+      const o = await options.suiClient.getObject({
+        id: poolInfo[poolName.toUpperCase()].investorId,
+        options: {
+          showContent: true,
+        },
+      });
+      const cetus_investor = o.data as CetusInvestor;
+
+      // Cache the investor object
+      cetusInvestorCache.set(cacheKey, cetus_investor);
+      return cetus_investor;
+    } catch (e) {
+      console.error(`getCetusInvestor failed for pool: ${poolName}`);
+      return undefined;
+    } finally {
+      // Remove the promise from the cache after it resolves
+      cetusInvestorPromiseCache.delete(cacheKey);
+    }
+  })();
+
+  // Cache the promise
+  cetusInvestorPromiseCache.set(cacheKey, cetusInvestorPromise);
+  return cetusInvestorPromise;
+}

package/src/getVaultBalances.ts

@@ -0,0 +1,128 @@
+import { getFullnodeUrl, SuiClient } from "@mysten/sui/client";
+import {
+  AlphaVaultBalance,
+  DoubleAssetVaultBalance,
+  PoolName,
+  SingleAssetVaultBalance,
+} from "./common/types";
+import {
+  getAlphaPortfolioAmount,
+  getAlphaPortfolioAmountInUSD,
+  getPortfolioAmount,
+  getPortfolioAmountInUSD,
+  getSingleAssetPortfolioAmount,
+  getSingleAssetPortfolioAmountInUSD,
+} from "./portfolioAmount";
+
+export async function getAlphaVaultBalance(
+  address: string,
+): Promise<AlphaVaultBalance | undefined> {
+  const suiClient = new SuiClient({
+    url: getFullnodeUrl("mainnet"),
+  });
+  if (address) {
+    const lockedPortfolioAmount = await getAlphaPortfolioAmount("ALPHA", {
+      suiClient,
+      address,
+      isLocked: true,
+    });
+    const lockedPortfolioAmountInUSD = await getAlphaPortfolioAmountInUSD(
+      "ALPHA",
+      { suiClient, address, isLocked: true },
+    );
+    const unlockedPortfolioAmount = await getAlphaPortfolioAmount("ALPHA", {
+      suiClient,
+      address,
+      isLocked: false,
+    });
+    const unlockedPortfolioAmountInUSD = await getAlphaPortfolioAmountInUSD(
+      "ALPHA",
+      { suiClient, address, isLocked: false },
+    );
+    const portfolioAmount = await getAlphaPortfolioAmount("ALPHA", {
+      suiClient,
+      address,
+    });
+    const portfolioAmountInUSD = await getAlphaPortfolioAmountInUSD("ALPHA", {
+      suiClient,
+      address,
+    });
+    if (
+      lockedPortfolioAmount !== undefined &&
+      lockedPortfolioAmountInUSD !== undefined &&
+      unlockedPortfolioAmount !== undefined &&
+      unlockedPortfolioAmountInUSD !== undefined &&
+      portfolioAmount !== undefined &&
+      portfolioAmountInUSD !== undefined
+    ) {
+      const res: AlphaVaultBalance = {
+        lockedAlphaCoins: lockedPortfolioAmount,
+        lockedAlphaCoinsInUSD: lockedPortfolioAmountInUSD,
+        unlockedAlphaCoins: unlockedPortfolioAmount,
+        unlockedAlphaCoinsInUSD: unlockedPortfolioAmountInUSD,
+        totalAlphaCoins: portfolioAmount,
+        totalAlphaCoinsInUSD: portfolioAmountInUSD,
+      };
+      return res;
+    }
+  }
+  return undefined;
+}
+
+export async function getDoubleAssetVaultBalance(
+  address: string,
+  poolName: PoolName,
+): Promise<DoubleAssetVaultBalance | undefined> {
+  const suiClient = new SuiClient({
+    url: getFullnodeUrl("mainnet"),
+  });
+  if (address && poolName) {
+    const portfolioAmount = await getPortfolioAmount(poolName as PoolName, {
+      suiClient,
+      address,
+    });
+    const portfolioAmountInUSD = await getPortfolioAmountInUSD(
+      poolName as PoolName,
+      { suiClient, address },
+    );
+    if (portfolioAmount !== undefined && portfolioAmountInUSD !== undefined) {
+      const res: DoubleAssetVaultBalance = {
+        coinA: portfolioAmount[0].toString(),
+        coinB: portfolioAmount[1].toString(),
+        valueInUSD: portfolioAmountInUSD,
+      };
+      return res;
+    }
+  }
+}
+
+export async function getSingleAssetVaultBalance(
+  address: string,
+  poolName: PoolName,
+): Promise<SingleAssetVaultBalance | undefined> {
+  const suiClient = new SuiClient({
+    url: getFullnodeUrl("mainnet"),
+  });
+  const portfolioAmount = await getSingleAssetPortfolioAmount(
+    poolName as PoolName,
+    {
+      suiClient,
+      address,
+    },
+  );
+  const portfolioAmountInUSD = await getSingleAssetPortfolioAmountInUSD(
+    poolName as PoolName,
+    {
+      suiClient,
+      address,
+    },
+  );
+  if (portfolioAmount !== undefined && portfolioAmountInUSD !== undefined) {
+    const res: SingleAssetVaultBalance = {
+      coin: portfolioAmount.toString(),
+      valueInUSD: portfolioAmountInUSD,
+    };
+    return res;
+  }
+  return undefined;
+}

package/src/getVaults.ts

@@ -0,0 +1,63 @@
+import { poolInfo } from "./common/maps";
+import { getFullnodeUrl, SuiClient } from "@mysten/sui/client";
+import { getReceipts } from "./functions";
+import { AlphaFiVault } from "./common/types";
+import { getPool } from "./portfolioAmount";
+
+function extractCoinTypes(input: string): {
+  coinTypeA: string | null;
+  coinTypeB: string | null;
+} {
+  let regex = /Pool<([^,>]+),\s*([^>]+)>/;
+  let match = input.match(regex);
+  if (!match) {
+    regex = /Pool<([^,>]+)>/;
+    match = input.match(regex);
+    if (!match) {
+      return { coinTypeA: null, coinTypeB: null };
+    }
+  }
+  const coinTypeA = match[1] || null;
+  const coinTypeB = match[2] || null;
+  return { coinTypeA, coinTypeB };
+}
+
+export async function getVaults(
+  address: string,
+): Promise<AlphaFiVault[] | undefined> {
+  const vaultsArr = [];
+  const suiClient = new SuiClient({
+    url: getFullnodeUrl("mainnet"),
+  });
+  if (address) {
+    for (const pool of Object.keys(poolInfo)) {
+      const receipt = await getReceipts(pool, { address, suiClient });
+      const poolObject = await getPool(pool, { suiClient });
+      if (receipt.length > 0 && poolObject) {
+        const name = receipt[0].content.fields.name;
+        const res: AlphaFiVault = {
+          poolId: poolInfo[pool].poolId,
+          poolName: null,
+          receiptName: name,
+          receiptType: receipt[0].content.type,
+          coinTypeA: extractCoinTypes(poolObject.content.type).coinTypeA,
+          coinTypeB: extractCoinTypes(poolObject.content.type).coinTypeB,
+        };
+        if (poolInfo[pool].parentProtocolName === "NAVI") {
+          res.poolName = name
+            .replace(/^AlphaFi-NAVI /, "")
+            .replace(/ Receipt$/, "");
+
+          res.poolName = "NAVI-" + res.poolName;
+        } else if (poolInfo[pool].parentProtocolName === "ALPHAFI") {
+          res.poolName = name.replace(/^AlphaFi /, "").replace(/ Receipt$/, "");
+        } else {
+          res.poolName = name.replace(/^AlphaFi /, "").replace(/ Receipt$/, "");
+        }
+        vaultsArr.push(res);
+      }
+    }
+    return vaultsArr;
+  }
+  return undefined;
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export { getVaults } from "./getVaults";
+export {
+  getAlphaVaultBalance,
+  getSingleAssetVaultBalance,
+  getDoubleAssetVaultBalance,
+} from "./getVaultBalances";
+export {
+  AlphaFiVault,
+  AlphaVaultBalance,
+  DoubleAssetVaultBalance,
+  SingleAssetVaultBalance,
+  PoolName,
+} from "./common/types";