@scallop-io/sui-scallop-sdk 1.4.15-rc.3 → 1.4.16

package/src/queries/portfolioQuery.ts

@@ -26,7 +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.
@@ -41,6 +46,8 @@ export const getLendings = async (
   query: ScallopQuery,
   poolCoinNames: SupportPoolCoins[] = [...SUPPORT_POOLS],
   ownerAddress?: string,
+  marketPools?: MarketPools,
+  coinPrices?: CoinPrices,
   indexer: boolean = false
 ) => {
   const marketCoinNames = poolCoinNames.map((poolCoinName) =>
@@ -50,13 +57,15 @@ export const getLendings = async (
     (SUPPORT_SPOOLS as readonly SupportMarketCoins[]).includes(marketCoinName)
   ) as SupportStakeMarketCoins[];
 
-  const coinPrices = await query.utils.getCoinPrices();
-  const marketPools = (
-    await query.getMarketPools(poolCoinNames, {
-      indexer,
-      coinPrices,
-    })
-  ).pools;
+  coinPrices = coinPrices ?? (await query.utils.getCoinPrices());
+  marketPools =
+    marketPools ??
+    (
+      await query.getMarketPools(poolCoinNames, {
+        indexer,
+        coinPrices,
+      })
+    ).pools;
 
   const spools = await query.getSpools(stakeMarketCoinNames, {
     indexer,
@@ -309,22 +318,34 @@ export const getLending = async (
 export const getObligationAccounts = async (
   query: ScallopQuery,
   ownerAddress?: string,
+  market?: {
+    pools: MarketPools;
+    collaterals: MarketCollaterals;
+  },
+  coinPrices?: CoinPrices,
   indexer: boolean = false
 ) => {
-  const coinPrices = await query.utils.getCoinPrices();
-  // const market = await query.queryMarket({ indexer, coinPrices });
-  const market = await query.getMarketPools(undefined, { coinPrices, indexer });
+  market = market ?? (await query.getMarketPools(undefined, { indexer }));
+  coinPrices =
+    coinPrices ??
+    (await query.getAllCoinPrices({
+      marketPools: market.pools,
+    }));
   const [coinAmounts, obligations] = await Promise.all([
     query.getCoinAmounts(undefined, ownerAddress),
     query.getObligations(ownerAddress),
   ]);
 
+  const obligationObjects = await queryMultipleObjects(
+    query.cache,
+    obligations.map((obligation) => obligation.id)
+  );
   const obligationAccounts: ObligationAccounts = {};
   await Promise.allSettled(
-    obligations.map(async (obligation) => {
+    obligations.map(async (obligation, idx) => {
       obligationAccounts[obligation.keyId] = await getObligationAccount(
         query,
-        obligation.id,
+        obligationObjects[idx] ?? obligation.id,
         ownerAddress,
         indexer,
         market,
@@ -341,13 +362,13 @@ export const getObligationAccounts = async (
  * Get obligation account data.
  *
  * @param query - The Scallop query instance.
- * @param obligationId - The obligation id.
+ * @param obligation - The obligation id.
  * @param indexer - Whether to use indexer.
  * @return Obligation account data.
  */
 export const getObligationAccount = async (
   query: ScallopQuery,
-  obligationId: string,
+  obligation: string | SuiObjectRef,
   ownerAddress?: string,
   indexer: boolean = false,
   market?: Market,
@@ -361,7 +382,6 @@ export const getObligationAccount = async (
     ...SUPPORT_COLLATERALS,
   ] as SupportCollateralCoins[];
 
-  // market = market ?? (await query.queryMarket({ indexer }));
   market = market ?? (await query.getMarketPools(undefined, { indexer }));
   coinPrices =
     coinPrices ?? (await query.getAllCoinPrices({ marketPools: market.pools }));
@@ -370,13 +390,12 @@ export const getObligationAccount = async (
 
   const [obligationQuery, borrowIncentivePools, borrowIncentiveAccounts] =
     await Promise.all([
-      query.queryObligation(obligationId),
+      query.queryObligation(obligation),
       query.getBorrowIncentivePools(undefined, {
         coinPrices,
-        indexer,
         marketPools: market.pools,
       }),
-      query.getBorrowIncentiveAccounts(obligationId),
+      query.getBorrowIncentiveAccounts(obligation),
     ]);
 
   const collaterals: ObligationAccount['collaterals'] = {};
@@ -656,7 +675,8 @@ export const getObligationAccount = async (
     : BigNumber(0);
 
   const obligationAccount: ObligationAccount = {
-    obligationId: obligationId,
+    obligationId:
+      typeof obligation === 'string' ? obligation : obligation.objectId,
     // Deposited collateral value (collateral balance)
     totalDepositedValue: totalDepositedValue.toNumber(),
     // Borrowed debt value (liabilities balance)
@@ -789,7 +809,6 @@ export const getTotalValueLocked = async (
   query: ScallopQuery,
   indexer: boolean = false
 ) => {
-  // const market = await query.queryMarket({ indexer });
   const market = await query.getMarketPools(undefined, { indexer });
 
   let supplyValue = BigNumber(0);
@@ -832,3 +851,216 @@ export const getTotalValueLocked = async (
 
   return tvl;
 };
+
+/**
+ * Get user portfolio by wallet address
+ */
+export const getUserPortfolio = async (
+  query: ScallopQuery,
+  walletAddress: string,
+  indexer: boolean = false
+) => {
+  const coinPrices = await query.utils.getCoinPrices();
+  const market = await query.getMarketPools(undefined, { indexer, coinPrices });
+
+  const [lendings, obligationAccounts, borrowIncentivePools, veScas] =
+    await Promise.all([
+      query.getLendings(undefined, walletAddress, {
+        indexer,
+        marketPools: market.pools,
+        coinPrices,
+      }),
+      query.getObligationAccounts(walletAddress, {
+        indexer,
+        market: market,
+        coinPrices,
+      }),
+      query.getBorrowIncentivePools(undefined, {
+        marketPools: market.pools,
+        coinPrices,
+      }),
+      query.getVeScas({ walletAddress, excludeEmpty: true }),
+    ]);
+
+  // 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;
+        }
+      >
+    );
+
+  const parsedVeScas = veScas.map(
+    ({ keyId, lockedScaCoin, currentVeScaBalance, unlockAt }) => ({
+      veScaKey: keyId,
+      coinPrice: coinPrices.sca ?? 0,
+      lockedScaInCoin: lockedScaCoin,
+      lockedScaInUsd: lockedScaCoin * (coinPrices.sca ?? 0),
+      currentVeScaBalance,
+      remainingLockPeriodInDays:
+        unlockAt - Date.now() > 0 ? (unlockAt - Date.now()) / 86400000 : 0,
+      unlockAt,
+    })
+  );
+
+  return {
+    totalSupplyValue: parsedLendings.reduce((acc, curr) => {
+      acc += curr.suppliedValue;
+      return acc;
+    }, 0),
+    ...parsedObligationAccounts.reduce(
+      (acc, curr) => {
+        acc.totalDebtValue += curr.totalDebtsInUsd;
+        acc.totalCollateralValue += curr.totalCollateralInUsd;
+        return acc;
+      },
+      {
+        totalDebtValue: 0,
+        totalCollateralValue: 0,
+      } as {
+        totalDebtValue: number;
+        totalCollateralValue: number;
+      }
+    ),
+    totalLockedScaValue: parsedVeScas.reduce((acc, curr) => {
+      acc += curr.lockedScaInUsd;
+      return acc;
+    }, 0),
+    lendings: parsedLendings,
+    borrowings: 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
+      ),
+    },
+    veScas: parsedVeScas,
+  };
+};

package/src/queries/priceQuery.ts

@@ -31,11 +31,7 @@ export const getPythPrice = async (
   );
   priceFeedObject =
     priceFeedObject ||
-    (
-      await address.cache.queryGetObject(pythFeedObjectId, {
-        showContent: true,
-      })
-    )?.data;
+    (await address.cache.queryGetObject(pythFeedObjectId))?.data;
 
   if (priceFeedObject) {
     const priceFeedPoolObject = priceFeedObject;
@@ -99,8 +95,7 @@ export const getPythPrices = async (
 
   // Fetch multiple objects at once to save rpc calls
   const priceFeedObjects = await address.cache.queryGetObjects(
-    Object.keys(pythPriceFeedIds),
-    { showContent: true }
+    Object.keys(pythPriceFeedIds)
   );
 
   const assetToPriceFeedMapping = priceFeedObjects.reduce(

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/queries/spoolQuery.ts

@@ -58,24 +58,33 @@ const queryRequiredSpoolObjects = async (
   // Map the results back to poolCoinNames
   const mapObjects = (
     tasks: { poolCoinName: string; [key: string]: string | undefined }[],
-    fetchedObjects: SuiObjectData[]
+    fetchedObjects: SuiObjectData[],
+    keyValue: string
   ) => {
     const resultMap: Record<string, SuiObjectData> = {};
-    let fetchedIndex = 0;
+    const fetchedObjectMap = fetchedObjects.reduce(
+      (acc, obj) => {
+        acc[obj.objectId] = obj;
+        return acc;
+      },
+      {} as Record<string, SuiObjectData>
+    );
 
     for (const task of tasks) {
-      const key = task[Object.keys(task)[1]]; // current object key being queried
-      if (key) {
-        resultMap[task.poolCoinName] = fetchedObjects[fetchedIndex];
-        fetchedIndex++;
+      if (task[keyValue]) {
+        resultMap[task.poolCoinName] = fetchedObjectMap[task[keyValue]];
       }
     }
     return resultMap;
   };
 
-  const spoolMap = mapObjects(tasks, spoolObjects);
-  const spoolRewardMap = mapObjects(tasks, spoolRewardObjects);
-  const sCoinTreasuryMap = mapObjects(tasks, sCoinTreasuryObjects);
+  const spoolMap = mapObjects(tasks, spoolObjects, 'spool');
+  const spoolRewardMap = mapObjects(tasks, spoolRewardObjects, 'spoolReward');
+  const sCoinTreasuryMap = mapObjects(
+    tasks,
+    sCoinTreasuryObjects,
+    'sCoinTreasury'
+  );
 
   // Construct the final requiredObjects result
   return stakePoolCoinNames.reduce(
@@ -444,10 +453,7 @@ export const getStakePool = async (
 ) => {
   const poolId = utils.address.get(`spool.pools.${marketCoinName}.id`);
   let stakePool: StakePool | undefined = undefined;
-  const stakePoolObjectResponse = await utils.cache.queryGetObject(poolId, {
-    showContent: true,
-    showType: true,
-  });
+  const stakePoolObjectResponse = await utils.cache.queryGetObject(poolId);
   if (stakePoolObjectResponse?.data) {
     const stakePoolObject = stakePoolObjectResponse.data;
     const id = stakePoolObject.objectId;
@@ -506,13 +512,8 @@ export const getStakeRewardPool = async (
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
   let stakeRewardPool: StakeRewardPool | undefined = undefined;
-  const stakeRewardPoolObjectResponse = await utils.cache.queryGetObject(
-    poolId,
-    {
-      showContent: true,
-      showType: true,
-    }
-  );
+  const stakeRewardPoolObjectResponse =
+    await utils.cache.queryGetObject(poolId);
 
   if (stakeRewardPoolObjectResponse?.data) {
     const stakeRewardPoolObject = stakeRewardPoolObjectResponse.data;

package/src/queries/vescaQuery.ts

@@ -195,8 +195,7 @@ const getTotalVeScaTreasuryAmount = async (
   const resolvedRefreshArgs = await Promise.all(
     refreshArgs.map(async (arg) => {
       if (typeof arg === 'string') {
-        return (await utils.cache.queryGetObject(arg, { showContent: true }))
-          ?.data;
+        return (await utils.cache.queryGetObject(arg))?.data;
       }
       return arg;
     })
@@ -205,8 +204,7 @@ const getTotalVeScaTreasuryAmount = async (
   const resolvedVeScaAmountArgs = await Promise.all(
     veScaAmountArgs.map(async (arg) => {
       if (typeof arg === 'string') {
-        return (await utils.cache.queryGetObject(arg, { showContent: true }))
-          ?.data;
+        return (await utils.cache.queryGetObject(arg))?.data;
       }
       return arg;
     })
@@ -254,9 +252,7 @@ export const getVeScaTreasuryInfo = async (
   utils: ScallopUtils
 ): Promise<VeScaTreasuryInfo | null> => {
   const veScaTreasuryId = utils.address.get('vesca.treasury');
-  const veScaTreasury = await utils.cache.queryGetObject(veScaTreasuryId, {
-    showContent: true,
-  });
+  const veScaTreasury = await utils.cache.queryGetObject(veScaTreasuryId);
 
   if (!veScaTreasury || veScaTreasury.data?.content?.dataType !== 'moveObject')
     return null;

package/src/types/builder/core.ts

@@ -26,41 +26,54 @@ type ObligationKey = NestedResult;
 type ObligationHotPotato = NestedResult;
 
 export type CoreNormalMethods = {
+  // openObligation: () => Promise<
   openObligation: () => [Obligation, ObligationKey, ObligationHotPotato];
   returnObligation: (
     obligation: SuiObjectArg,
     obligationHotPotato: SuiObjectArg
+    // ) => Promise<void>;
   ) => void;
+  // openObligationEntry: () => Promise<void>;
   openObligationEntry: () => void;
   addCollateral: (
     obligation: SuiObjectArg,
     coin: SuiObjectArg,
     collateralCoinName: SupportCollateralCoins
+    // ) => Promise<void>;
   ) => void;
   takeCollateral: (
     obligation: SuiObjectArg,
     obligationKey: SuiObjectArg,
     amount: number,
     collateralCoinName: SupportCollateralCoins
+    // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   deposit: (
     coin: SuiObjectArg,
     poolCoinName: SupportPoolCoins
+    // ) => Promise<TransactionResult>;
+  ) => TransactionResult;
+  depositEntry: (
+    coin: SuiObjectArg,
+    poolCoinName: SupportPoolCoins
+    // ) => Promise<TransactionResult>;
   ) => TransactionResult;
-  depositEntry: (coin: SuiObjectArg, poolCoinName: SupportPoolCoins) => void;
   withdraw: (
     marketCoin: SuiObjectArg,
     poolCoinName: SupportPoolCoins
+    // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   withdrawEntry: (
     marketCoin: SuiObjectArg,
     poolCoinName: SupportPoolCoins
-  ) => void;
+    // ) => Promise<TransactionResult>;
+  ) => TransactionResult;
   borrow: (
     obligation: SuiObjectArg,
     obligationKey: SuiObjectArg,
     amount: number,
     poolCoinName: SupportPoolCoins
+    // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   borrowWithReferral: (
     obligation: SuiObjectArg,
@@ -68,26 +81,31 @@ export type CoreNormalMethods = {
     borrowReferral: SuiObjectArg,
     amount: number | SuiTxArg,
     poolCoinName: SupportPoolCoins
+    // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   borrowEntry: (
     obligation: SuiObjectArg,
     obligationKey: SuiObjectArg,
     amount: number,
     poolCoinName: SupportPoolCoins
-  ) => void;
+    // ) => Promise<TransactionResult>;
+  ) => TransactionResult;
   repay: (
     obligation: SuiObjectArg,
     coin: SuiObjectArg,
     poolCoinName: SupportPoolCoins
+    // ) => Promise<void>;
   ) => void;
   borrowFlashLoan: (
     amount: number | SuiTxArg,
     poolCoinName: SupportPoolCoins
+    // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   repayFlashLoan: (
     coin: SuiObjectArg,
     loan: SuiObjectArg,
     poolCoinName: SupportPoolCoins
+    // ) => Promise<void>;
   ) => void;
 };
 

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/src/utils/query.ts

@@ -167,10 +167,10 @@ export const calculateMarketPoolData = (
     conversionRate: conversionRate.toNumber(),
     isIsolated: parsedMarketPoolData.isIsolated,
     maxSupplyCoin: BigNumber(parsedMarketPoolData.supplyLimit)
-      .shiftedBy(coinDecimal)
+      .shiftedBy(-coinDecimal)
       .toNumber(),
     maxBorrowCoin: BigNumber(parsedMarketPoolData.borrowLimit)
-      .shiftedBy(coinDecimal)
+      .shiftedBy(-coinDecimal)
       .toNumber(),
   };
 };

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;