@scallop-io/sui-scallop-sdk 1.3.5-rc.1 → 1.4.0

package/src/queries/priceQuery.ts

@@ -1,14 +1,6 @@
 import { SuiObjectData } from '@mysten/sui/client';
-import type { ScallopAddress, ScallopQuery } from '../models';
-import type {
-  CoinPrices,
-  MarketPools,
-  OptionalKeys,
-  SupportAssetCoins,
-  SupportSCoin,
-} from '../types';
-import { SUPPORT_SCOIN } from 'src/constants/common';
-import BigNumber from 'bignumber.js';
+import type { ScallopAddress } from '../models';
+import type { SupportAssetCoins } from '../types';
 
 /**
  * Get price from pyth fee object.
@@ -134,29 +126,3 @@ export const getPythPrices = async (
     {} as Record<SupportAssetCoins, number>
   );
 };
-
-export const getAllCoinPrices = async (
-  query: ScallopQuery,
-  marketPools?: MarketPools,
-  coinPrices?: CoinPrices
-) => {
-  coinPrices = coinPrices ?? (await query.utils.getCoinPrices());
-  marketPools =
-    marketPools ??
-    (await query.getMarketPools(undefined, undefined, { coinPrices }));
-  if (!marketPools) {
-    throw new Error(`Failed to fetch market pool for getAllCoinPrices`);
-  }
-  const sCoinPrices: OptionalKeys<Record<SupportSCoin, number>> = {};
-  SUPPORT_SCOIN.forEach((sCoinName) => {
-    const coinName = query.utils.parseCoinName(sCoinName);
-    sCoinPrices[sCoinName] = BigNumber(coinPrices[coinName] ?? 0)
-      .multipliedBy(marketPools[coinName]?.conversionRate ?? 1)
-      .toNumber();
-  });
-
-  return {
-    ...coinPrices,
-    ...sCoinPrices,
-  };
-};

package/src/queries/sCoinQuery.ts

@@ -139,8 +139,8 @@ export const getSCoinSwapRate = async (
 
   // Get lending data for both sCoin A and sCoin B
   const marketPools = await Promise.all([
-    query.getMarketPool(fromCoinName, false),
-    query.getMarketPool(toCoinName, false),
+    query.getMarketPool(fromCoinName),
+    query.getMarketPool(toCoinName),
   ]);
   if (marketPools.some((pool) => !pool))
     throw new Error('Failed to fetch the lendings data');
@@ -153,7 +153,7 @@ export const getSCoinSwapRate = async (
   const BtoSCoinBRate = 1 / marketPools[1]!.conversionRate;
 
   const calcAtoBRate = async () => {
-    const prices = await query.utils.getCoinPrices();
+    const prices = await query.utils.getCoinPrices([fromCoinName, toCoinName]);
     if (!prices[fromCoinName] || !prices[toCoinName]) {
       throw new Error('Failed to fetch the coin prices');
     }

package/src/queries/spoolQuery.ts

@@ -43,7 +43,7 @@ export const getSpools = async (
   coinPrices = coinPrices ?? (await query.utils.getCoinPrices()) ?? {};
 
   marketPools =
-    marketPools ?? (await query.getMarketPools(stakeCoinNames, indexer));
+    marketPools ?? (await query.getMarketPools(stakeCoinNames, { indexer }));
   if (!marketPools)
     throw new Error(`Fail to fetch marketPools for ${stakeCoinNames}`);
 
@@ -71,6 +71,7 @@ export const getSpools = async (
     };
     Object.values(spoolsIndexer).forEach(updateSpools);
 
+    // console.log(spools);
     return spools;
   }
 
@@ -111,7 +112,7 @@ export const getSpool = async (
   coinPrices?: CoinPrices
 ) => {
   const coinName = query.utils.parseCoinName<SupportStakeCoins>(marketCoinName);
-  marketPool = marketPool || (await query.getMarketPool(coinName, indexer));
+  marketPool = marketPool || (await query.getMarketPool(coinName, { indexer }));
   if (!marketPool) {
     throw new Error(`Failed to fetch marketPool for ${marketCoinName}`);
   }
@@ -121,7 +122,7 @@ export const getSpool = async (
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
   let spool: Spool | undefined = undefined;
-  coinPrices = coinPrices || (await query.utils.getCoinPrices());
+  coinPrices = coinPrices || (await query.utils.getCoinPrices([coinName]));
 
   if (indexer) {
     const spoolIndexer = await query.indexer.getSpool(marketCoinName);
@@ -151,7 +152,8 @@ export const getSpool = async (
   }
 
   const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
-  coinPrices = coinPrices || (await query.utils.getCoinPrices());
+  coinPrices =
+    coinPrices || (await query.utils.getCoinPrices([coinName, rewardCoinName]));
 
   const spoolObject = spoolObjectResponse[0];
   const rewardPoolObject = spoolObjectResponse[1];

package/src/types/builder/borrowIncentive.ts

@@ -4,7 +4,10 @@ import type {
 } from '@scallop-io/sui-kit';
 import type { TransactionResult } from '@mysten/sui/transactions';
 import type { ScallopBuilder } from '../../models';
-import type { SupportBorrowIncentiveRewardCoins } from '../constant';
+import type {
+  SupportBorrowIncentiveCoins,
+  SupportBorrowIncentiveRewardCoins,
+} from '../constant';
 
 export type BorrowIncentiveIds = {
   borrowIncentivePkg: string;
@@ -32,6 +35,7 @@ export type BorrowIncentiveNormalMethods = {
   claimBorrowIncentive: (
     obligation: SuiObjectArg,
     obligationKey: SuiObjectArg,
+    coinName: SupportBorrowIncentiveCoins,
     rewardType: SupportBorrowIncentiveRewardCoins
   ) => TransactionResult;
   deactivateBoost: (obligation: SuiObjectArg, veScaKey: SuiObjectArg) => void;
@@ -39,22 +43,23 @@ export type BorrowIncentiveNormalMethods = {
 
 export type BorrowIncentiveQuickMethods = {
   stakeObligationQuick(
-    obligation?: string,
-    obligationKey?: string
+    obligation?: SuiObjectArg,
+    obligationKey?: SuiObjectArg
   ): Promise<void>;
   stakeObligationWithVeScaQuick(
-    obligation?: string,
-    obligationKey?: string,
-    veScaKey?: string
+    obligation?: SuiObjectArg,
+    obligationKey?: SuiObjectArg,
+    veScaKey?: SuiObjectArg
   ): Promise<void>;
   unstakeObligationQuick(
-    obligation?: string,
-    obligationKey?: string
+    obligation?: SuiObjectArg,
+    obligationKey?: SuiObjectArg
   ): Promise<void>;
   claimBorrowIncentiveQuick(
+    coinName: SupportBorrowIncentiveCoins,
     rewardType: SupportBorrowIncentiveRewardCoins,
-    obligation?: string,
-    obligationKey?: string
+    obligation?: SuiObjectArg,
+    obligationKey?: SuiObjectArg
   ): Promise<TransactionResult>;
 };
 

package/src/types/constant/common.ts

@@ -23,7 +23,8 @@ export type SupportCoins =
 export type SupportAssetCoins =
   | SupportPoolCoins
   | SupportCollateralCoins
-  | SupportStakeRewardCoins;
+  | SupportStakeRewardCoins
+  | SupportBorrowIncentiveRewardCoins;
 export type SupportPoolCoins = (typeof SUPPORT_POOLS)[number];
 export type SupportCollateralCoins = (typeof SUPPORT_COLLATERALS)[number];
 export type SupportMarketCoins =

package/src/types/utils.ts

@@ -1,10 +1,18 @@
-import type { SupportCoins } from './constant';
+import type { SupportAssetCoins } from './constant';
 
 export type OptionalKeys<T> = {
   [K in keyof T]?: T[K];
 };
 
-export type CoinPrices = OptionalKeys<Record<SupportCoins, number>>;
+export type CoinPrices = OptionalKeys<Record<SupportAssetCoins, number>>;
+
+export type PriceMap = Map<
+  SupportAssetCoins,
+  {
+    price: number;
+    publishTime: number;
+  }
+>;
 
 export type PoolAddressInfo = {
   name: string;

package/src/utils/indexer.ts

@@ -11,14 +11,20 @@ export async function callMethodWithIndexerFallback(
   context: any,
   ...args: any[]
 ) {
-  const indexer = args[args.length - 1]; // Assume last argument is always `indexer`
+  const lastArgs = args[args.length - 1]; // Assume last argument is always `indexer`
 
-  if (indexer) {
+  if (typeof lastArgs === 'object' && lastArgs.indexer) {
     try {
       return await method.apply(context, args);
     } catch (e: any) {
       console.warn(`Indexer requests failed: ${e}. Retrying without indexer..`);
-      return await method.apply(context, [...args.slice(0, -1), false]);
+      return await method.apply(context, [
+        ...args.slice(0, -1),
+        {
+          ...lastArgs,
+          indexer: false,
+        },
+      ]);
     }
   }
   return await method.apply(context, args);

package/src/utils/query.ts

@@ -546,6 +546,93 @@ export const calculateBorrowIncentivePoolPointData = (
   };
 };
 
+// /**
+//  *  Parse origin borrow incentive reward pool data to a more readable format.
+//  *
+//  * @param originBorrowIncentiveRewardPoolData - Origin borrow incentive reward pool data
+//  * @return Parsed borrow incentive reward pool data
+//  */
+// export const parseOriginBorrowIncentiveRewardPoolData = (
+//   originBorrowIncentiveRewardPoolData: OriginBorrowIncentiveRewardPoolData
+// ): ParsedBorrowIncentiveRewardPoolData => {
+//   return {
+//     rewardType: normalizeStructTag(
+//       originBorrowIncentiveRewardPoolData.reward_type.name
+//     ),
+//     claimedRewards: Number(originBorrowIncentiveRewardPoolData.claimed_rewards),
+//     exchangeRateNumerator: Number(
+//       originBorrowIncentiveRewardPoolData.exchange_rate_numerator
+//     ),
+//     exchangeRateDenominator: Number(
+//       originBorrowIncentiveRewardPoolData.exchange_rate_denominator
+//     ),
+//     remainingRewards: Number(
+//       originBorrowIncentiveRewardPoolData.remaining_reward
+//     ),
+//   };
+// };
+
+// export const calculateBorrowIncentiveRewardPoolData = (
+//   parsedBorrowIncentivePoolData: ParsedBorrowIncentivePoolData,
+//   parsedBorrowIncentiveRewardPoolData: ParsedBorrowIncentiveRewardPoolData,
+//   calculatedBorrowIncentivePoolData: CalculatedBorrowIncentivePoolData,
+//   rewardCoinPrice: number,
+//   rewardCoinDecimal: number
+// ): CalculatedBorrowIncentiveRewardPoolData => {
+//   const rateYearFactor = 365 * 24 * 60 * 60;
+
+//   const rewardPerSec = BigNumber(
+//     calculatedBorrowIncentivePoolData.distributedPointPerSec
+//   )
+//     .multipliedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateNumerator)
+//     .dividedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateDenominator);
+//   const totalRewardAmount = BigNumber(parsedBorrowIncentivePoolData.maxPoint)
+//     .multipliedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateNumerator)
+//     .dividedBy(parsedBorrowIncentiveRewardPoolData.exchangeRateDenominator);
+//   const totalRewardCoin = totalRewardAmount.shiftedBy(-1 * rewardCoinDecimal);
+//   const totalRewardValue = totalRewardCoin.multipliedBy(rewardCoinPrice);
+//   const remaindRewardAmount = BigNumber(
+//     parsedBorrowIncentiveRewardPoolData.remainingRewards
+//   );
+//   const remaindRewardCoin = remaindRewardAmount.shiftedBy(
+//     -1 * rewardCoinDecimal
+//   );
+//   const remaindRewardValue = remaindRewardCoin.multipliedBy(rewardCoinPrice);
+//   const claimedRewardAmount = BigNumber(
+//     parsedBorrowIncentiveRewardPoolData.claimedRewards
+//   );
+//   const claimedRewardCoin = claimedRewardAmount.shiftedBy(
+//     -1 * rewardCoinDecimal
+//   );
+//   const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
+
+//   const rewardValueForYear = BigNumber(rewardPerSec)
+//     .shiftedBy(-1 * rewardCoinDecimal)
+//     .multipliedBy(rateYearFactor)
+//     .multipliedBy(rewardCoinPrice);
+//   const rewardRate = rewardValueForYear
+//     .dividedBy(calculatedBorrowIncentivePoolData.stakedValue)
+//     .isFinite()
+//     ? rewardValueForYear
+//         .dividedBy(calculatedBorrowIncentivePoolData.stakedValue)
+//         .toNumber()
+//     : Infinity;
+
+//   return {
+//     rewardApr: rewardRate,
+//     totalRewardAmount: totalRewardAmount.toNumber(),
+//     totalRewardCoin: totalRewardCoin.toNumber(),
+//     totalRewardValue: totalRewardValue.toNumber(),
+//     remaindRewardAmount: remaindRewardAmount.toNumber(),
+//     remaindRewardCoin: remaindRewardCoin.toNumber(),
+//     remaindRewardValue: remaindRewardValue.toNumber(),
+//     claimedRewardAmount: claimedRewardAmount.toNumber(),
+//     claimedRewardCoin: claimedRewardCoin.toNumber(),
+//     claimedRewardValue: claimedRewardValue.toNumber(),
+//     rewardPerSec: rewardPerSec.toNumber(),
+//   };
+// };
+
 export const parseOriginBorrowIncentiveAccountPoolPointData = (
   originBorrowIncentiveAccountPoolPointData: OriginBorrowIncentiveAccountPoolData
 ): ParsedBorrowIncentiveAccountPoolData => {

package/src/utils/tokenBucket.ts

@@ -38,8 +38,8 @@ const callWithRateLimit = async <T>(
   tokenBucket: TokenBucket,
   fn: () => Promise<T>,
   retryDelayInMs = DEFAULT_INTERVAL_IN_MS,
-  maxRetries = 30,
-  backoffFactor = 1.25 // The factor by which to increase the delay
+  maxRetries = 15,
+  backoffFactor = 2 // The factor by which to increase the delay
 ): Promise<T | null> => {
   let retries = 0;