@scallop-io/sui-scallop-sdk 1.4.6 → 1.4.7

package/src/queries/portfolioQuery.ts

@@ -26,9 +26,12 @@ import type {
   ObligationBorrowIcentiveReward,
   SupportBorrowIncentiveRewardCoins,
   SupportAssetCoins,
+  MarketPools,
+  MarketCollaterals,
 } from '../types';
 import { SuiObjectRef } from '@mysten/sui/client';
 import { queryMultipleObjects } from './objectsQuery';
+import { normalizeStructTag, SUI_TYPE_ARG } from '@scallop-io/sui-kit';
 
 /**
  * Get user lending infomation for specific pools.
@@ -43,6 +46,7 @@ export const getLendings = async (
   query: ScallopQuery,
   poolCoinNames: SupportPoolCoins[] = [...SUPPORT_POOLS],
   ownerAddress?: string,
+  marketPools?: MarketPools,
   indexer: boolean = false
 ) => {
   const marketCoinNames = poolCoinNames.map((poolCoinName) =>
@@ -53,12 +57,14 @@ export const getLendings = async (
   ) as SupportStakeMarketCoins[];
 
   const coinPrices = await query.utils.getCoinPrices();
-  const marketPools = (
-    await query.getMarketPools(poolCoinNames, {
-      indexer,
-      coinPrices,
-    })
-  ).pools;
+  marketPools =
+    marketPools ??
+    (
+      await query.getMarketPools(poolCoinNames, {
+        indexer,
+        coinPrices,
+      })
+    ).pools;
 
   const spools = await query.getSpools(stakeMarketCoinNames, {
     indexer,
@@ -311,9 +317,13 @@ export const getLending = async (
 export const getObligationAccounts = async (
   query: ScallopQuery,
   ownerAddress?: string,
+  market?: {
+    pools: MarketPools;
+    collaterals: MarketCollaterals;
+  },
   indexer: boolean = false
 ) => {
-  const market = await query.getMarketPools(undefined, { indexer });
+  market = market ?? (await query.getMarketPools(undefined, { indexer }));
   const coinPrices = await query.getAllCoinPrices({
     marketPools: market.pools,
   });
@@ -379,7 +389,6 @@ export const getObligationAccount = async (
       query.queryObligation(obligation),
       query.getBorrowIncentivePools(undefined, {
         coinPrices,
-        indexer,
         marketPools: market.pools,
       }),
       query.getBorrowIncentiveAccounts(obligation),
@@ -838,3 +847,195 @@ export const getTotalValueLocked = async (
 
   return tvl;
 };
+
+/**
+ * Get user portfolio by wallet address
+ */
+export const getUserPortfolio = async (
+  query: ScallopQuery,
+  walletAddress: string,
+  indexer: boolean = false
+) => {
+  const market = await query.getMarketPools();
+  const [lendings, obligationAccounts, borrowIncentivePools] =
+    await Promise.all([
+      query.getLendings(undefined, walletAddress, {
+        indexer,
+        marketPools: market.pools,
+      }),
+      query.getObligationAccounts(walletAddress, {
+        indexer,
+        market: market,
+      }),
+      query.getBorrowIncentivePools(undefined, {
+        marketPools: market.pools,
+      }),
+    ]);
+
+  // get pending rewards (spool and borrow incentive)
+  const parsedLendings = Object.values(lendings)
+    .filter((t) => t.availableWithdrawCoin > 0)
+    .map((lending) => ({
+      suppliedCoin: lending.availableWithdrawCoin,
+      suppliedValue: lending.suppliedValue,
+      stakedCoin: lending.availableUnstakeCoin,
+      coinName: lending.coinName,
+      symbol: lending.symbol,
+      coinType: lending.coinType,
+      coinPrice: lending.coinPrice,
+      coinDecimals: lending.coinDecimal,
+      supplyApr: lending.supplyApr,
+      supplyApy: lending.supplyApy,
+      incentiveApr: isFinite(lending.rewardApr) ? lending.rewardApr : 0,
+    }));
+
+  const parsedObligationAccounts = Object.values(obligationAccounts)
+    .filter(
+      (t): t is NonNullable<typeof t> =>
+        !!t && t.totalBorrowedValueWithWeight > 0
+    )
+    .map((obligationAccount) => {
+      return {
+        obligationId: obligationAccount.obligationId,
+        totalDebtsInUsd: obligationAccount.totalBorrowedValueWithWeight,
+        totalCollateralInUsd: obligationAccount.totalDepositedValue,
+        riskLevel: obligationAccount.totalRiskLevel,
+        availableCollateralInUsd:
+          obligationAccount.totalAvailableCollateralValue,
+        totalUnhealthyCollateralInUsd:
+          obligationAccount.totalUnhealthyCollateralValue,
+        borrowedPools: Object.values(obligationAccount.debts)
+          .filter((debt) => debt.borrowedCoin > 0)
+          .map((debt) => ({
+            coinName: debt.coinName,
+            symbol: debt.symbol,
+            coinDecimals: debt.coinDecimal,
+            coinType: debt.coinType,
+            coinPrice: debt.coinPrice,
+            borrowedCoin: debt.borrowedCoin,
+            borrowedValueInUsd: debt.borrowedValueWithWeight,
+            borrowApr: market.pools[debt.coinName]?.borrowApr,
+            borrowApy: market.pools[debt.coinName]?.borrowApy,
+            incentiveInfos: Object.values(
+              borrowIncentivePools[debt.coinName]?.points ?? {}
+            )
+              .filter((t) => isFinite(t.rewardApr))
+              .map((t) => ({
+                coinName: t.coinName,
+                symbol: t.symbol,
+                coinType: t.coinType,
+                incentiveApr: t.rewardApr,
+              })),
+          })),
+      };
+    });
+
+  const pendingLendingRewards = Object.values(lendings).reduce(
+    (acc, reward) => {
+      if (reward.availableClaimCoin === 0) return acc;
+      if (!acc[reward.symbol]) {
+        acc[reward.symbol] = {
+          symbol: reward.symbol,
+          coinType: normalizeStructTag(SUI_TYPE_ARG), // @TODO: for now lending reward is all in SUI
+          coinPrice: reward.coinPrice,
+          pendingRewardInCoin: reward.availableClaimCoin,
+        };
+      } else {
+        acc[reward.symbol].pendingRewardInCoin += reward.availableClaimCoin;
+      }
+      return acc;
+    },
+    {} as Record<
+      string,
+      {
+        coinType: string;
+        symbol: string;
+        coinPrice: number;
+        pendingRewardInCoin: number;
+      }
+    >
+  );
+
+  const pendingBorrowIncentiveRewards = Object.values(obligationAccounts)
+    .filter((t): t is NonNullable<typeof t> => !!t)
+    .reduce(
+      (acc, curr) => {
+        Object.values(curr.borrowIncentives).forEach((incentive) => {
+          incentive.rewards.forEach((reward) => {
+            if (reward.availableClaimCoin === 0) return acc;
+            if (!acc[reward.coinName]) {
+              acc[reward.coinName] = {
+                symbol: reward.symbol,
+                coinType: reward.coinType,
+                coinPrice: reward.coinPrice,
+                pendingRewardInCoin: reward.availableClaimCoin,
+              };
+            } else {
+              acc[reward.coinName].pendingRewardInCoin +=
+                reward.availableClaimCoin;
+            }
+          });
+        });
+        return acc;
+      },
+      {} as Record<
+        string,
+        {
+          coinType: string;
+          symbol: string;
+          coinPrice: number;
+          pendingRewardInCoin: number;
+        }
+      >
+    );
+  return {
+    lendings: {
+      totalSupplyValue: parsedLendings.reduce((acc, curr) => {
+        acc += curr.suppliedValue;
+        return acc;
+      }, 0),
+      suppliedPools: parsedLendings,
+    },
+    borrowings: {
+      ...parsedObligationAccounts.reduce(
+        (acc, curr) => {
+          acc.totalDebtValue += curr.totalDebtsInUsd;
+          acc.totalCollateralValue += curr.totalCollateralInUsd;
+          return acc;
+        },
+        {
+          totalDebtValue: 0,
+          totalCollateralValue: 0,
+        } as {
+          totalDebtValue: number;
+          totalCollateralValue: number;
+        }
+      ),
+      obligations: parsedObligationAccounts,
+    },
+    pendingRewards: {
+      lendings: Object.entries(pendingLendingRewards).reduce(
+        (acc, [key, value]) => {
+          acc.push({
+            ...value,
+            coinName: key,
+            pendingRewardInUsd: value.coinPrice * value.pendingRewardInCoin,
+          });
+          return acc;
+        },
+        [] as any
+      ),
+      borrowIncentives: Object.entries(pendingBorrowIncentiveRewards).reduce(
+        (acc, [key, value]) => {
+          acc.push({
+            coinName: key,
+            ...value,
+            pendingRewardInUsd: value.coinPrice * value.pendingRewardInCoin,
+          });
+          return acc;
+        },
+        [] as any
+      ),
+    },
+  };
+};

package/src/queries/sCoinQuery.ts

@@ -95,11 +95,11 @@ export const getSCoinAmount = async (
 ) => {
   const owner = ownerAddress || utils.suiKit.currentAddress();
   const sCoinType = utils.parseSCoinType(sCoinName);
-  const amount = await utils.cache.queryGetCoinBalance({
+  const coinBalance = await utils.cache.queryGetCoinBalance({
     owner,
     coinType: sCoinType,
   });
-  return BigNumber(amount).toNumber();
+  return BigNumber(coinBalance?.totalBalance ?? '0').toNumber();
 };
 
 const isSupportStakeCoins = (value: string): value is SupportSCoin => {

package/src/types/model.ts

@@ -10,6 +10,7 @@ import type {
 } from '../models';
 import { ScallopCache } from 'src/models/scallopCache';
 import { AddressesInterface } from './address';
+import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
 
 export type ScallopClientFnReturnType<T extends boolean> = T extends true
   ? SuiTransactionBlockResponse
@@ -26,7 +27,9 @@ export type ScallopBaseInstanceParams = {
   suiKit?: SuiKit;
 };
 
-export type ScallopCacheInstanceParams = ScallopBaseInstanceParams;
+export type ScallopCacheInstanceParams = ScallopBaseInstanceParams & {
+  queryClient?: QueryClient;
+};
 
 export type ScallopAddressInstanceParams = ScallopBaseInstanceParams & {
   cache?: ScallopCache;
@@ -69,7 +72,8 @@ export type ScallopParams = {
 export type ScallopClientParams = ScallopParams &
   ScallopBuilderParams &
   ScallopQueryParams &
-  ScallopUtilsParams;
+  ScallopUtilsParams &
+  ScallopCacheParams;
 
 export type ScallopBuilderParams = ScallopParams & {
   pythEndpoints?: string[];
@@ -81,3 +85,10 @@ export type ScallopQueryParams = ScallopParams & ScallopUtilsParams;
 export type ScallopUtilsParams = ScallopParams & {
   pythEndpoints?: string[];
 };
+
+export type ScallopCacheParams = Omit<
+  ScallopParams,
+  'addressId' | 'forceAddressesInterface'
+> & {
+  cacheOptions?: QueryClientConfig;
+};

package/src/utils/index.ts

@@ -1,7 +1,5 @@
 export * from './builder';
 export * from './query';
 export * from './util';
-export * from './tokenBucket';
 export * from './indexer';
 export * from './core';
-export * from './tokenBucket';

package/src/utils/indexer.ts

@@ -17,7 +17,9 @@ export async function callMethodWithIndexerFallback(
     try {
       return await method.apply(context, args);
     } catch (e: any) {
-      console.warn(`Indexer requests failed: ${e}. Retrying without indexer..`);
+      console.warn(
+        `Indexer requests failed: ${e.message}. Retrying without indexer..`
+      );
       return await method.apply(context, [
         ...args.slice(0, -1),
         {

package/dist/constants/tokenBucket.d.ts

@@ -1,2 +0,0 @@
-export declare const DEFAULT_TOKENS_PER_INTERVAL = 10;
-export declare const DEFAULT_INTERVAL_IN_MS = 250;

package/dist/utils/tokenBucket.d.ts

@@ -1,11 +0,0 @@
-declare class TokenBucket {
-    private tokensPerInterval;
-    private interval;
-    private tokens;
-    private lastRefill;
-    constructor(tokensPerInterval: number, intervalInMs: number);
-    refill(): void;
-    removeTokens(count: number): boolean;
-}
-declare const callWithRateLimit: <T>(tokenBucket: TokenBucket, fn: () => Promise<T>, retryDelayInMs?: number, maxRetries?: number, backoffFactor?: number) => Promise<T | null>;
-export { TokenBucket, callWithRateLimit };

package/src/constants/tokenBucket.ts

@@ -1,2 +0,0 @@
-export const DEFAULT_TOKENS_PER_INTERVAL = 10;
-export const DEFAULT_INTERVAL_IN_MS = 250;

package/src/utils/tokenBucket.ts

@@ -1,68 +0,0 @@
-import { DEFAULT_INTERVAL_IN_MS } from 'src/constants/tokenBucket';
-
-class TokenBucket {
-  private tokensPerInterval: number;
-  private interval: number;
-  private tokens: number;
-  private lastRefill: number;
-
-  constructor(tokensPerInterval: number, intervalInMs: number) {
-    this.tokensPerInterval = tokensPerInterval;
-    this.interval = intervalInMs;
-    this.tokens = tokensPerInterval;
-    this.lastRefill = Date.now();
-  }
-
-  refill() {
-    const now = Date.now();
-    const elapsed = now - this.lastRefill;
-
-    if (elapsed >= this.interval) {
-      const tokensToAdd =
-        Math.floor(elapsed / this.interval) * this.tokensPerInterval;
-      this.tokens = Math.min(this.tokens + tokensToAdd, this.tokensPerInterval);
-
-      // Update lastRefill to reflect the exact time of the last "refill"
-      this.lastRefill += Math.floor(elapsed / this.interval) * this.interval;
-    }
-  }
-
-  removeTokens(count: number) {
-    this.refill();
-    if (this.tokens >= count) {
-      this.tokens -= count;
-      return true;
-    }
-    return false;
-  }
-}
-
-const callWithRateLimit = async <T>(
-  tokenBucket: TokenBucket,
-  fn: () => Promise<T>,
-  retryDelayInMs = DEFAULT_INTERVAL_IN_MS,
-  maxRetries = 15,
-  backoffFactor = 1.25 // The factor by which to increase the delay
-): Promise<T | null> => {
-  let retries = 0;
-
-  const tryRequest = async (): Promise<T | null> => {
-    if (tokenBucket.removeTokens(1)) {
-      const result = await fn();
-      return result;
-    } else if (retries < maxRetries) {
-      retries++;
-      const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
-      // console.error(`Rate limit exceeded, retrying in ${delay} ms`);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      return tryRequest();
-    } else {
-      console.error('Maximum retries reached');
-      return null;
-    }
-  };
-
-  return tryRequest();
-};
-
-export { TokenBucket, callWithRateLimit };