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

package/src/models/scallopAddress.ts

@@ -1,5 +1,5 @@
 import { API_BASE_URL, USE_TEST_ADDRESS } from '../constants';
-import { SuiKit, type NetworkType } from '@scallop-io/sui-kit';
+import { type NetworkType } from '@scallop-io/sui-kit';
 import type {
   ScallopAddressParams,
   AddressesInterface,
@@ -7,7 +7,6 @@ import type {
   ScallopAddressInstanceParams,
 } from '../types';
 import { ScallopCache } from './scallopCache';
-import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 import axios, { AxiosInstance } from 'axios';
 import { TEST_ADDRESSES } from 'src/constants/testAddress';
 import { queryKeys } from 'src/constants';
@@ -379,13 +378,7 @@ export class ScallopAddress {
     instance?: ScallopAddressInstanceParams
   ) {
     const { id, auth, network, forceInterface } = params;
-    this.cache =
-      instance?.cache ??
-      new ScallopCache(
-        instance?.suiKit ?? new SuiKit({}),
-        undefined,
-        DEFAULT_CACHE_OPTIONS
-      );
+    this.cache = instance?.cache ?? new ScallopCache({});
 
     this._requestClient = axios.create({
       baseURL: API_BASE_URL,

package/src/models/scallopBuilder.ts

@@ -24,7 +24,6 @@ import type {
   SelectCoinReturnType,
 } from '../types';
 import { ScallopCache } from './scallopCache';
-import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 import { newSuiKit } from './suiKit';
 
 /**
@@ -66,11 +65,9 @@ export class ScallopBuilder {
       this.address = this.utils.address;
       this.cache = this.address.cache;
     } else {
-      this.cache = new ScallopCache(
-        this.suiKit,
-        this.walletAddress,
-        DEFAULT_CACHE_OPTIONS
-      );
+      this.cache = new ScallopCache(this.params, {
+        suiKit: this.suiKit,
+      });
       this.address = new ScallopAddress(
         {
           id: params?.addressesId ?? ADDRESSES_ID,

package/src/models/scallopCache.ts

@@ -1,4 +1,4 @@
-import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
+import { QueryClient } from '@tanstack/query-core';
 import {
   SuiObjectArg,
   SuiTxBlock,
@@ -17,14 +17,12 @@ import type {
   GetDynamicFieldObjectParams,
   GetBalanceParams,
   SuiClient,
+  CoinBalance,
 } from '@mysten/sui/client';
 import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
-import { callWithRateLimit, TokenBucket } from 'src/utils';
-import {
-  DEFAULT_INTERVAL_IN_MS,
-  DEFAULT_TOKENS_PER_INTERVAL,
-} from 'src/constants/tokenBucket';
 import { queryKeys } from 'src/constants';
+import { ScallopCacheInstanceParams, ScallopCacheParams } from 'src/types';
+import { newSuiKit } from './suiKit';
 
 type QueryInspectTxnParams = {
   queryTarget: string;
@@ -32,6 +30,9 @@ type QueryInspectTxnParams = {
   typeArgs?: any[];
 };
 
+const DEFAULT_TOKENS_PER_INTERVAL = 10;
+const DEFAULT_INTERVAL_IN_MS = 250;
+
 /**
  * @description
  * It provides caching for moveCall, RPC Request, and API Request.
@@ -46,20 +47,26 @@ type QueryInspectTxnParams = {
  */
 
 export class ScallopCache {
-  public readonly queryClient: QueryClient;
-  public readonly _suiKit: SuiKit;
-  private tokenBucket: TokenBucket;
+  public readonly params: ScallopCacheParams;
+
+  public queryClient: QueryClient;
+  public suiKit: SuiKit;
+  // private tokenBucket: TokenBucket;
   public walletAddress: string;
+  private tokensPerInterval: number = DEFAULT_TOKENS_PER_INTERVAL;
+  private interval: number = DEFAULT_INTERVAL_IN_MS;
+  private tokens: number;
+  private lastRefill: number;
 
   public constructor(
-    suiKit: SuiKit,
-    walletAddress?: string,
-    cacheOptions?: QueryClientConfig,
-    tokenBucket?: TokenBucket,
-    queryClient?: QueryClient
+    params: ScallopCacheParams,
+    instance?: ScallopCacheInstanceParams
   ) {
+    this.params = params;
+    this.suiKit = instance?.suiKit ?? newSuiKit(params);
     this.queryClient =
-      queryClient ?? new QueryClient(cacheOptions ?? DEFAULT_CACHE_OPTIONS);
+      instance?.queryClient ??
+      new QueryClient(params?.cacheOptions ?? DEFAULT_CACHE_OPTIONS);
 
     // handle case where there's existing queryClient and cacheOptions is also passed
     // if (queryClient && cacheOptions) {
@@ -71,22 +78,62 @@ export class ScallopCache {
     //   // if(cacheOptions.mutations)this.queryClient.setMutationDefaults(cacheOptions.mutations);
     // }
 
-    this._suiKit = suiKit;
-    this.tokenBucket =
-      tokenBucket ??
-      new TokenBucket(DEFAULT_TOKENS_PER_INTERVAL, DEFAULT_INTERVAL_IN_MS);
-    this.walletAddress = walletAddress ?? suiKit.currentAddress();
+    this.tokens = this.tokensPerInterval;
+    this.lastRefill = Date.now();
+    this.walletAddress = params.walletAddress ?? this.suiKit.currentAddress();
   }
 
-  private get suiKit(): SuiKit {
-    if (!this._suiKit) {
-      throw new Error('SuiKit instance is not initialized');
+  private get client(): SuiClient {
+    return this.suiKit.client();
+  }
+
+  private 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;
     }
-    return this._suiKit;
   }
 
-  private get client(): SuiClient {
-    return this.suiKit.client();
+  private removeTokens(count: number) {
+    this.refill();
+    if (this.tokens >= count) {
+      this.tokens -= count;
+      return true;
+    }
+    return false;
+  }
+
+  private async callWithRateLimit<T>(
+    fn: () => Promise<T>,
+    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 (this.removeTokens(1)) {
+        const result = await fn();
+        return result;
+      } else if (retries < maxRetries) {
+        retries++;
+        const delay = this.interval * 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();
   }
 
   /**
@@ -98,14 +145,14 @@ export class ScallopCache {
    * - `all`: All queries that match the refetch predicate will be refetched in the background.
    * - `none`: No queries will be refetched. Queries that match the refetch predicate will only be marked as invalid.
    */
-  public async invalidateAllCache() {
-    return Object.values(queryKeys.rpc).map((t) =>
-      this.queryClient.invalidateQueries({
-        queryKey: t(),
-        type: 'all',
-      })
-    );
-  }
+  // public async invalidateAllCache() {
+  //   return Object.values(queryKeys.rpc).map((t) =>
+  //     this.queryClient.invalidateQueries({
+  //       queryKey: t(),
+  //       type: 'all',
+  //     })
+  //   );
+  // }
 
   private retryFn(errCount: number, e: any) {
     if (errCount === 5) return false;
@@ -168,8 +215,7 @@ export class ScallopCache {
       retryDelay: 1000,
       queryKey: queryKeys.rpc.getInspectTxn(queryTarget, args, typeArgs),
       queryFn: async () => {
-        return await callWithRateLimit(
-          this.tokenBucket,
+        return await this.callWithRateLimit(
           async () => await this.suiKit.inspectTxn(txBlock)
         );
       },
@@ -182,8 +228,7 @@ export class ScallopCache {
     return this.queryClient.fetchQuery({
       queryKey: queryKeys.rpc.getNormalizedMoveFunction(target),
       queryFn: async () => {
-        return await callWithRateLimit(
-          this.tokenBucket,
+        return await this.callWithRateLimit(
           async () =>
             await this.suiKit.client().getNormalizedMoveFunction({
               package: address,
@@ -215,8 +260,7 @@ export class ScallopCache {
       retryDelay: 1000,
       queryKey: queryKeys.rpc.getObject(objectId, options),
       queryFn: async () => {
-        return await callWithRateLimit(
-          this.tokenBucket,
+        return await this.callWithRateLimit(
           async () =>
             await this.client.getObject({
               id: objectId,
@@ -250,8 +294,7 @@ export class ScallopCache {
         options
       ),
       queryFn: async () => {
-        const results = await callWithRateLimit(
-          this.tokenBucket,
+        const results = await this.callWithRateLimit(
           async () => await this.suiKit.getObjects(objectIds, options)
         );
         if (results) {
@@ -288,8 +331,7 @@ export class ScallopCache {
       retryDelay: 1000,
       queryKey: queryKeys.rpc.getOwnedObjects(input),
       queryFn: async () => {
-        const results = await callWithRateLimit(
-          this.tokenBucket,
+        const results = await this.callWithRateLimit(
           async () => await this.client.getOwnedObjects(input)
         );
         if (results && results.data.length > 0) {
@@ -332,8 +374,7 @@ export class ScallopCache {
       retryDelay: 1000,
       queryKey: queryKeys.rpc.getDynamicFields(input),
       queryFn: async () => {
-        return await callWithRateLimit(
-          this.tokenBucket,
+        return await this.callWithRateLimit(
           async () => await this.client.getDynamicFields(input)
         );
       },
@@ -348,7 +389,7 @@ export class ScallopCache {
       retryDelay: (attemptIndex) => Math.min(1000 * attemptIndex, 8000),
       queryKey: queryKeys.rpc.getDynamicFieldObject(input),
       queryFn: async () => {
-        const result = await callWithRateLimit(this.tokenBucket, () =>
+        const result = await this.callWithRateLimit(() =>
           this.client.getDynamicFieldObject(input)
         );
         if (result?.data) {
@@ -376,26 +417,24 @@ export class ScallopCache {
 
   public async queryGetAllCoinBalances(
     owner: string
-  ): Promise<{ [k: string]: string }> {
+  ): Promise<{ [k: string]: CoinBalance }> {
     return this.queryClient.fetchQuery({
       retry: this.retryFn,
       retryDelay: 1000,
       queryKey: queryKeys.rpc.getAllCoinBalances(owner),
       queryFn: async () => {
-        const allBalances = await callWithRateLimit(
-          this.tokenBucket,
+        const allBalances = await this.callWithRateLimit(
           async () => await this.client.getAllBalances({ owner })
         );
         if (!allBalances) return {};
         const balances = allBalances.reduce(
           (acc, coinBalance) => {
             if (coinBalance.totalBalance !== '0') {
-              acc[normalizeStructTag(coinBalance.coinType)] =
-                coinBalance.totalBalance;
+              acc[normalizeStructTag(coinBalance.coinType)] = coinBalance;
             }
             return acc;
           },
-          {} as { [k: string]: string }
+          {} as { [k: string]: CoinBalance }
         );
 
         return balances;
@@ -403,8 +442,10 @@ export class ScallopCache {
     });
   }
 
-  public async queryGetCoinBalance(input: GetBalanceParams): Promise<string> {
-    if (!input.coinType) return '0';
+  public async queryGetCoinBalance(
+    input: GetBalanceParams
+  ): Promise<CoinBalance | null> {
+    if (!input.coinType) return null;
 
     return (
       ((await this.queryGetAllCoinBalances(input.owner)) ?? {})[

package/src/models/scallopClient.ts

@@ -1,6 +1,5 @@
 import { normalizeSuiAddress } from '@mysten/sui/utils';
 import { SuiKit } from '@scallop-io/sui-kit';
-import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 import {
   ADDRESSES_ID,
   SUPPORT_BORROW_INCENTIVE_POOLS,
@@ -75,11 +74,9 @@ export class ScallopClient {
       this.address = this.utils.address;
       this.cache = this.address.cache;
     } else {
-      this.cache = new ScallopCache(
-        this.suiKit,
-        this.walletAddress,
-        DEFAULT_CACHE_OPTIONS
-      );
+      this.cache = new ScallopCache(this.params, {
+        suiKit: this.suiKit,
+      });
       this.address = new ScallopAddress(
         {
           id: params?.addressesId ?? ADDRESSES_ID,

package/src/models/scallopIndexer.ts

@@ -22,8 +22,6 @@ import type {
   ScallopIndexerInstanceParams,
 } from '../types';
 import { ScallopCache } from './scallopCache';
-import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
-import { SuiKit } from '@scallop-io/sui-kit';
 import { queryKeys } from 'src/constants';
 
 /**
@@ -48,9 +46,7 @@ export class ScallopIndexer {
     instance?: ScallopIndexerInstanceParams
   ) {
     this.params = params;
-    this.cache =
-      instance?.cache ??
-      new ScallopCache(new SuiKit({}), undefined, DEFAULT_CACHE_OPTIONS);
+    this.cache = instance?.cache ?? new ScallopCache(this.params);
     this._requestClient = axios.create({
       baseURL: SDK_API_BASE_URL,
       headers: {

package/src/models/scallopQuery.ts

@@ -1,10 +1,5 @@
 import { SuiKit, SuiObjectArg } from '@scallop-io/sui-kit';
-import {
-  ADDRESSES_ID,
-  SUPPORT_POOLS,
-  SUPPORT_SPOOLS,
-  DEFAULT_CACHE_OPTIONS,
-} from '../constants';
+import { ADDRESSES_ID, SUPPORT_POOLS, SUPPORT_SPOOLS } from '../constants';
 import {
   queryMarket,
   getObligations,
@@ -47,6 +42,7 @@ import {
   getAllCoinPrices,
   getAllAddresses,
   isIsolatedAsset,
+  getUserPortfolio,
 } from '../queries';
 import {
   ScallopQueryParams,
@@ -63,6 +59,7 @@ import {
   MarketPool,
   CoinPrices,
   MarketPools,
+  MarketCollaterals,
 } from '../types';
 import { ScallopAddress } from './scallopAddress';
 import { ScallopUtils } from './scallopUtils';
@@ -112,11 +109,9 @@ export class ScallopQuery {
       this.address = instance.utils.address;
       this.cache = this.address.cache;
     } else {
-      this.cache = new ScallopCache(
-        this.suiKit,
-        this.walletAddress,
-        DEFAULT_CACHE_OPTIONS
-      );
+      this.cache = new ScallopCache(this.params, {
+        suiKit: this.suiKit,
+      });
       this.address = new ScallopAddress(
         {
           id: params?.addressesId ?? ADDRESSES_ID,
@@ -582,9 +577,15 @@ export class ScallopQuery {
   public async getLendings(
     poolCoinNames?: SupportPoolCoins[],
     ownerAddress: string = this.walletAddress,
-    args?: { indexer?: boolean }
+    args?: { indexer?: boolean; marketPools?: MarketPools }
   ) {
-    return await getLendings(this, poolCoinNames, ownerAddress, args?.indexer);
+    return await getLendings(
+      this,
+      poolCoinNames,
+      ownerAddress,
+      args?.marketPools,
+      args?.indexer
+    );
   }
 
   /**
@@ -615,9 +616,20 @@ export class ScallopQuery {
    */
   public async getObligationAccounts(
     ownerAddress: string = this.walletAddress,
-    args?: { indexer?: boolean }
+    args?: {
+      indexer?: boolean;
+      market?: {
+        collaterals: MarketCollaterals;
+        pools: MarketPools;
+      };
+    }
   ) {
-    return await getObligationAccounts(this, ownerAddress, args?.indexer);
+    return await getObligationAccounts(
+      this,
+      ownerAddress,
+      args?.market,
+      args?.indexer
+    );
   }
 
   /**
@@ -844,10 +856,24 @@ export class ScallopQuery {
   }
 
   /**
-   * Query all address (lending pool, collateral pool, borrow dynamics, interest models) of all pool
+   * Query all address (lending pool, collateral pool, borrow dynamics, interest models, etc.) of all pool
    * @returns
    */
   public async getPoolAddresses() {
     return getAllAddresses(this);
   }
+
+  /**
+   * Get user portfolio
+   */
+  public async getUserPortfolio(args?: {
+    walletAddress?: string;
+    indexer?: boolean;
+  }) {
+    return getUserPortfolio(
+      this,
+      args?.walletAddress ?? this.walletAddress,
+      args?.indexer ?? false
+    );
+  }
 }

package/src/models/scallopUtils.ts

@@ -33,7 +33,6 @@ import {
 } from '../utils';
 import { PYTH_ENDPOINTS, PYTH_FEED_IDS } from 'src/constants/pyth';
 import { ScallopCache } from './scallopCache';
-import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 import type {
   ScallopUtilsParams,
   SupportCoins,
@@ -81,21 +80,18 @@ export class ScallopUtils {
       pythEndpoints: params.pythEndpoints ?? PYTH_ENDPOINTS['mainnet'],
       ...params,
     };
+    this.walletAddress =
+      params.walletAddress ?? instance?.suiKit?.currentAddress() ?? '';
     this.suiKit =
-      instance?.suiKit ?? instance?.address?.cache._suiKit ?? newSuiKit(params);
-
-    this.walletAddress = params.walletAddress ?? this.suiKit.currentAddress();
+      instance?.suiKit ?? instance?.address?.cache.suiKit ?? newSuiKit(params);
 
     if (instance?.address) {
       this.address = instance.address;
       this.cache = this.address.cache;
-      this.suiKit = this.address.cache._suiKit;
     } else {
-      this.cache = new ScallopCache(
-        this.suiKit,
-        this.walletAddress,
-        DEFAULT_CACHE_OPTIONS
-      );
+      this.cache = new ScallopCache(this.params, {
+        suiKit: this.suiKit,
+      });
       this.address =
         instance?.address ??
         new ScallopAddress(
@@ -450,7 +446,7 @@ export class ScallopUtils {
     coinType: string = SUI_TYPE_ARG,
     ownerAddress?: string
   ) {
-    ownerAddress = ownerAddress ?? this.suiKit.currentAddress();
+    ownerAddress = ownerAddress ?? this.walletAddress;
     const coins = await this.suiKit.suiInteractor.selectCoins(
       ownerAddress,
       amount,

package/src/queries/coreQuery.ts

@@ -1079,11 +1079,11 @@ export const getCoinAmount = async (
 ) => {
   const owner = ownerAddress ?? query.suiKit.currentAddress();
   const coinType = query.utils.parseCoinType(assetCoinName);
-  const amount = await query.cache.queryGetCoinBalance({
+  const coinBalance = await query.cache.queryGetCoinBalance({
     owner,
     coinType: coinType,
   });
-  return BigNumber(amount).toNumber();
+  return BigNumber(coinBalance?.totalBalance ?? '0').toNumber();
 };
 
 /**
@@ -1136,11 +1136,11 @@ export const getMarketCoinAmount = async (
 ) => {
   const owner = ownerAddress ?? query.suiKit.currentAddress();
   const marketCoinType = query.utils.parseMarketCoinType(marketCoinName);
-  const amount = await query.cache.queryGetCoinBalance({
+  const coinBalance = await query.cache.queryGetCoinBalance({
     owner,
     coinType: marketCoinType,
   });
-  return BigNumber(amount).toNumber();
+  return BigNumber(coinBalance?.totalBalance ?? '0').toNumber();
 };
 
 /**

package/src/queries/poolAddressesQuery.ts

@@ -12,6 +12,7 @@ export const getAllAddresses = async (query: ScallopQuery) => {
         borrowDynamic?: string;
         spoolReward?: string;
         spool?: string;
+        sCoinType?: string;
         sCoinTreasury?: string;
         interestModel?: string;
         riskModel?: string;
@@ -21,6 +22,7 @@ export const getAllAddresses = async (query: ScallopQuery) => {
         isolatedAssetKey?: string;
         coinDecimalId?: string;
         borrowIncentivePoolId?: string;
+        coinType?: string;
       }
     >
   > = {};
@@ -115,6 +117,8 @@ export const getAllAddresses = async (query: ScallopQuery) => {
         // @ts-ignore
         `spool.pools.s${coinName}.rewardPoolId`
       );
+      // @ts-ignore
+      const sCoinType = query.address.get(`scoin.coins.s${coinName}.coinType`);
       const sCoinTreasury = query.address.get(
         // @ts-ignore
         `scoin.coins.s${coinName}.treasury`
@@ -135,7 +139,9 @@ export const getAllAddresses = async (query: ScallopQuery) => {
         spool,
         spoolReward: rewardPool,
         sCoinTreasury,
+        sCoinType,
         coinDecimalId,
+        coinType,
       };
 
       await new Promise((resolve) => setTimeout(resolve, 200));