@scallop-io/sui-scallop-sdk 1.3.41 → 1.4.1-alpha.1

package/src/queries/portfolioQuery.ts

@@ -1,6 +1,5 @@
 import BigNumber from 'bignumber.js';
 import {
-  SUPPORT_BORROW_INCENTIVE_REWARDS,
   SUPPORT_COLLATERALS,
   SUPPORT_POOLS,
   SUPPORT_SPOOLS,
@@ -50,11 +49,13 @@ export const getLendings = async (
     (SUPPORT_SPOOLS as readonly SupportMarketCoins[]).includes(marketCoinName)
   ) as SupportStakeMarketCoins[];
 
-  const coinPrices = await query.utils.getCoinPrices(poolCoinNames);
-  const marketPools = await query.getMarketPools(poolCoinNames, indexer, {
+  const coinPrices = await query.utils.getCoinPrices();
+  const marketPools = await query.getMarketPools(poolCoinNames, {
+    indexer,
     coinPrices,
   });
-  const spools = await query.getSpools(stakeMarketCoinNames, indexer, {
+  const spools = await query.getSpools(stakeMarketCoinNames, {
+    indexer,
     marketPools,
     coinPrices,
   });
@@ -122,13 +123,12 @@ export const getLending = async (
 ) => {
   const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
   coinPrice =
-    coinPrice ??
-    (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ??
-    0;
+    coinPrice ?? (await query.utils.getCoinPrices())?.[poolCoinName] ?? 0;
 
   marketPool =
     marketPool ??
-    (await query.getMarketPool(poolCoinName, indexer, {
+    (await query.getMarketPool(poolCoinName, {
+      indexer,
       coinPrice,
     }));
 
@@ -138,16 +138,13 @@ export const getLending = async (
   spool =
     (spool ??
     (SUPPORT_SPOOLS as readonly SupportMarketCoins[]).includes(marketCoinName))
-      ? await query.getSpool(
-          marketCoinName as SupportStakeMarketCoins,
+      ? await query.getSpool(marketCoinName as SupportStakeMarketCoins, {
           indexer,
-          {
-            marketPool,
-            coinPrices: {
-              [poolCoinName]: coinPrice,
-            },
-          }
-        )
+          marketPool,
+          coinPrices: {
+            [poolCoinName]: coinPrice,
+          },
+        })
       : undefined;
   // some pool does not have spool
   // if (!spool) throw new Error(`Failed to fetch spool for ${poolCoinName}`);
@@ -311,7 +308,7 @@ export const getObligationAccounts = async (
   indexer: boolean = false
 ) => {
   const coinPrices = await query.utils.getCoinPrices();
-  const market = await query.queryMarket(indexer, { coinPrices });
+  const market = await query.queryMarket({ indexer, coinPrices });
   const [coinAmounts, obligations] = await Promise.all([
     query.getCoinAmounts(undefined, ownerAddress),
     query.getObligations(ownerAddress),
@@ -355,9 +352,9 @@ export const getObligationAccount = async (
   const collateralAssetCoinNames: SupportCollateralCoins[] = [
     ...SUPPORT_COLLATERALS,
   ];
+  market = market ?? (await query.queryMarket({ indexer }));
   coinPrices =
-    coinPrices ?? (await query.utils.getCoinPrices(collateralAssetCoinNames));
-  market = market ?? (await query.queryMarket(indexer, { coinPrices }));
+    coinPrices ?? (await query.getAllCoinPrices({ marketPools: market.pools }));
   coinAmounts =
     coinAmounts ||
     (await query.getCoinAmounts(collateralAssetCoinNames, ownerAddress));
@@ -365,8 +362,9 @@ export const getObligationAccount = async (
   const [obligationQuery, borrowIncentivePools, borrowIncentiveAccounts] =
     await Promise.all([
       query.queryObligation(obligationId),
-      query.getBorrowIncentivePools(undefined, indexer, {
+      query.getBorrowIncentivePools(undefined, {
         coinPrices,
+        indexer,
       }),
       query.getBorrowIncentiveAccounts(obligationId),
     ]);
@@ -525,64 +523,70 @@ export const getObligationAccount = async (
     const borrowIncentivePool = borrowIncentivePools[coinName];
     if (borrowIncentivePool) {
       const rewards: ObligationBorrowIcentiveReward[] = [];
-      for (const rewardCoinName of SUPPORT_BORROW_INCENTIVE_REWARDS) {
-        const accountPoint = borrowIncentiveAccount.pointList[rewardCoinName];
-        const poolPoint = borrowIncentivePool.points[rewardCoinName];
-
-        if (accountPoint && poolPoint) {
-          let availableClaimAmount = BigNumber(0);
-          let availableClaimCoin = BigNumber(0);
-          const accountBorrowedAmount = BigNumber(accountPoint.weightedAmount);
-          const baseIndexRate = 1_000_000_000;
-          const increasedPointRate = poolPoint.currentPointIndex
-            ? Math.max(
-                BigNumber(poolPoint.currentPointIndex - accountPoint.index)
-                  .dividedBy(baseIndexRate)
-                  .toNumber(),
-                0
-              )
-            : 1;
-          availableClaimAmount = availableClaimAmount.plus(
-            accountBorrowedAmount
-              .multipliedBy(increasedPointRate)
-              .plus(accountPoint.points)
-          );
-          availableClaimCoin = availableClaimAmount.shiftedBy(
-            -1 * poolPoint.coinDecimal
-          );
-
-          // for veSCA
-          const weightScale = BigNumber(1_000_000_000_000);
-          const boostValue = BigNumber(accountPoint.weightedAmount)
-            .div(
-              BigNumber(borrowIncentiveAccount.debtAmount)
-                .multipliedBy(poolPoint.baseWeight)
-                .dividedBy(weightScale)
-            )
-            .isFinite()
-            ? BigNumber(accountPoint.weightedAmount)
-                .div(
-                  BigNumber(borrowIncentiveAccount.debtAmount)
-                    .multipliedBy(poolPoint.baseWeight)
-                    .dividedBy(weightScale)
+      Object.entries(borrowIncentiveAccount.pointList).forEach(
+        ([key, accountPoint]) => {
+          const poolPoint =
+            borrowIncentivePool.points[
+              key as SupportBorrowIncentiveRewardCoins
+            ];
+
+          if (accountPoint && poolPoint) {
+            let availableClaimAmount = BigNumber(0);
+            let availableClaimCoin = BigNumber(0);
+            const accountBorrowedAmount = BigNumber(
+              accountPoint.weightedAmount
+            );
+            const baseIndexRate = 1_000_000_000;
+            const increasedPointRate = poolPoint.currentPointIndex
+              ? Math.max(
+                  BigNumber(poolPoint.currentPointIndex - accountPoint.index)
+                    .dividedBy(baseIndexRate)
+                    .toNumber(),
+                  0
                 )
-                .toNumber()
-            : 1;
-
-          if (availableClaimAmount.isGreaterThanOrEqualTo(0)) {
-            rewards.push({
-              coinName: poolPoint.coinName,
-              coinType: poolPoint.coinType,
-              symbol: poolPoint.symbol,
-              coinDecimal: poolPoint.coinDecimal,
-              coinPrice: poolPoint.coinPrice,
-              availableClaimAmount: availableClaimAmount.toNumber(),
-              availableClaimCoin: availableClaimCoin.toNumber(),
-              boostValue,
-            });
+              : 1;
+            availableClaimAmount = availableClaimAmount.plus(
+              accountBorrowedAmount
+                .multipliedBy(increasedPointRate)
+                .plus(accountPoint.points)
+            );
+            availableClaimCoin = availableClaimAmount.shiftedBy(
+              -1 * poolPoint.coinDecimal
+            );
+
+            // for veSCA
+            const weightScale = BigNumber(1_000_000_000_000);
+            const boostValue = BigNumber(accountPoint.weightedAmount)
+              .div(
+                BigNumber(borrowIncentiveAccount.debtAmount)
+                  .multipliedBy(poolPoint.baseWeight)
+                  .dividedBy(weightScale)
+              )
+              .isFinite()
+              ? BigNumber(accountPoint.weightedAmount)
+                  .div(
+                    BigNumber(borrowIncentiveAccount.debtAmount)
+                      .multipliedBy(poolPoint.baseWeight)
+                      .dividedBy(weightScale)
+                  )
+                  .toNumber()
+              : 1;
+
+            if (availableClaimAmount.isGreaterThanOrEqualTo(0)) {
+              rewards.push({
+                coinName: poolPoint.coinName,
+                coinType: poolPoint.coinType,
+                symbol: poolPoint.symbol,
+                coinDecimal: poolPoint.coinDecimal,
+                coinPrice: poolPoint.coinPrice,
+                availableClaimAmount: availableClaimAmount.toNumber(),
+                availableClaimCoin: availableClaimCoin.toNumber(),
+                boostValue,
+              });
+            }
           }
         }
-      }
+      );
 
       if (
         Object.keys(borrowIncentivePool.points).some((coinName: any) => {
@@ -770,7 +774,7 @@ export const getTotalValueLocked = async (
   query: ScallopQuery,
   indexer: boolean = false
 ) => {
-  const market = await query.queryMarket(indexer);
+  const market = await query.queryMarket({ indexer });
 
   let supplyValue = BigNumber(0);
   let borrowValue = BigNumber(0);

package/src/queries/priceQuery.ts

@@ -1,6 +1,14 @@
 import { SuiObjectData } from '@mysten/sui/client';
-import type { ScallopAddress } from '../models';
-import type { SupportAssetCoins } from '../types';
+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';
 
 /**
  * Get price from pyth fee object.
@@ -126,3 +134,28 @@ 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, { 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([fromCoinName, toCoinName]);
+    const prices = await query.utils.getCoinPrices();
     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,7 +71,6 @@ export const getSpools = async (
     };
     Object.values(spoolsIndexer).forEach(updateSpools);
 
-    // console.log(spools);
     return spools;
   }
 
@@ -112,7 +111,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}`);
   }
@@ -122,7 +121,7 @@ export const getSpool = async (
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
   let spool: Spool | undefined = undefined;
-  coinPrices = coinPrices || (await query.utils.getCoinPrices([coinName]));
+  coinPrices = coinPrices || (await query.utils.getCoinPrices());
 
   if (indexer) {
     const spoolIndexer = await query.indexer.getSpool(marketCoinName);
@@ -152,8 +151,7 @@ export const getSpool = async (
   }
 
   const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
-  coinPrices =
-    coinPrices || (await query.utils.getCoinPrices([coinName, rewardCoinName]));
+  coinPrices = coinPrices || (await query.utils.getCoinPrices());
 
   const spoolObject = spoolObjectResponse[0];
   const rewardPoolObject = spoolObjectResponse[1];

package/src/queries/supplyLimitQuery.ts

@@ -17,8 +17,9 @@ const supplyLimitZod = zod.object({
   }),
 });
 
-const supplyLimitKeyType = `0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::SupplyLimitKey`; // prod
-// const supplyLimitKeyType = `0x6c23585e940a989588432509107e98bae06dbca4e333f26d0635d401b3c7c76d::market_dynamic_keys::SupplyLimitKey`;
+// TODO: enable for production
+// const supplyLimitKeyType = `0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::SupplyLimitKey`; // prod
+const supplyLimitKeyType = `0x6c23585e940a989588432509107e98bae06dbca4e333f26d0635d401b3c7c76d::market_dynamic_keys::SupplyLimitKey`;
 /**
  * Return supply limit of a pool (including the decimals)
  * @param utils

package/src/test.ts

@@ -0,0 +1,20 @@
+// import { ScallopQuery } from './models';
+
+// const main = async () => {
+//   try {
+//     const query = new ScallopQuery({
+//       walletAddress:
+//         '0x61819c99588108d9f7710047e6ad8f2da598de8e98a26ea62bd7ad9847f5329c',
+//     });
+//     await query.init();
+
+//     const res = await query.getAllCoinPrices();
+//     console.dir(res, { depth: null });
+//   } catch (e) {
+//     console.error(e);
+//   } finally {
+//     process.exit(0);
+//   }
+// };
+
+// main();

package/src/types/builder/borrowIncentive.ts

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

package/src/types/constant/common.ts

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

package/src/types/utils.ts

@@ -1,18 +1,10 @@
-import type { SupportAssetCoins } from './constant';
+import type { SupportCoins } from './constant';
 
 export type OptionalKeys<T> = {
   [K in keyof T]?: T[K];
 };
 
-export type CoinPrices = OptionalKeys<Record<SupportAssetCoins, number>>;
-
-export type PriceMap = Map<
-  SupportAssetCoins,
-  {
-    price: number;
-    publishTime: number;
-  }
->;
+export type CoinPrices = OptionalKeys<Record<SupportCoins, 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,93 +546,6 @@ 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;