@scallop-io/sui-scallop-sdk 0.44.27 → 0.45.0

package/src/models/scallopCache.ts

@@ -0,0 +1,245 @@
+import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
+import { SuiTxArg, SuiTxBlock } from '@scallop-io/sui-kit';
+import { SuiKit } from '@scallop-io/sui-kit';
+import type {
+  SuiObjectResponse,
+  SuiObjectDataOptions,
+  SuiObjectData,
+  PaginatedObjectsResponse,
+  GetOwnedObjectsParams,
+  DevInspectResults,
+  GetDynamicFieldsParams,
+  DynamicFieldPage,
+  GetDynamicFieldObjectParams,
+} from '@mysten/sui.js/client';
+import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
+
+type QueryInspectTxnParams = {
+  queryTarget: string;
+  args: SuiTxArg[];
+  typeArgs?: any[];
+};
+
+/**
+ * @description
+ * It provides caching for moveCall, RPC Request, and API Request.
+ *
+ *
+ * @example
+ * ```typescript
+ * const scallopCache = new scallopCache(<parameters>);
+ * scallopCache.<indexer functions>();
+ * await scallopCache.<indexer async functions>();
+ * ```
+ */
+
+export class ScallopCache {
+  public readonly queryClient: QueryClient;
+  public readonly _suiKit?: SuiKit;
+
+  public constructor(cacheOptions?: QueryClientConfig, suiKit?: SuiKit) {
+    this.queryClient = new QueryClient(cacheOptions ?? DEFAULT_CACHE_OPTIONS);
+    this._suiKit = suiKit;
+  }
+
+  private get suiKit(): SuiKit {
+    if (!this._suiKit) {
+      throw new Error('SuiKit instance is not initialized');
+    }
+    return this._suiKit;
+  }
+
+  /**
+   * @description Invalidate cache based on the refetchType parameter
+   * @param refetchType Determines the type of queries to be refetched. Defaults to `active`.
+   *
+   * - `active`: Only queries that match the refetch predicate and are actively being rendered via useQuery and related functions will be refetched in the background.
+   * - `inactive`: Only queries that match the refetch predicate and are NOT actively being rendered via useQuery and related functions will be refetched in the background.
+   * - `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 invalidateAndRefetchAllCache(
+    refetchType: 'all' | 'active' | 'inactive' | 'none'
+  ) {
+    return this.queryClient.invalidateQueries({
+      refetchType,
+    });
+  }
+
+  /**
+   * @description Cache protocol config call for 60 seconds.
+   * @returns Promise<ProtocolConfig>
+   */
+  private async getProtocolConfig() {
+    return await this.queryClient.fetchQuery({
+      queryKey: ['getProtocolConfig'],
+      queryFn: async () => {
+        return await this.suiKit.client().getProtocolConfig();
+      },
+      staleTime: 30000,
+    });
+  }
+
+  /**
+   * @description Provides cache for inspectTxn of the SuiKit.
+   * @param QueryInspectTxnParams
+   * @param txBlock
+   * @returns Promise<DevInspectResults>
+   */
+  public async queryInspectTxn({
+    queryTarget,
+    args,
+    typeArgs,
+  }: QueryInspectTxnParams): Promise<DevInspectResults> {
+    const txBlock = new SuiTxBlock();
+
+    // resolve all the object args to prevent duplicate getNormalizedMoveFunction calls
+    const resolvedArgs = await Promise.all(
+      args.map(async (arg) => {
+        if (typeof arg === 'string') {
+          return (await this.queryGetObject(arg, { showContent: true })).data;
+        }
+        return arg;
+      })
+    );
+    txBlock.moveCall(queryTarget, resolvedArgs, typeArgs);
+
+    // build the txBlock to prevent duplicate getProtocolConfig calls
+    const txBytes = await txBlock.txBlock.build({
+      client: this.suiKit.client(),
+      onlyTransactionKind: true,
+      protocolConfig: await this.getProtocolConfig(),
+    });
+
+    const query = await this.queryClient.fetchQuery({
+      queryKey: typeArgs
+        ? ['inspectTxn', queryTarget, JSON.stringify(args)]
+        : [
+            'inspectTxn',
+            queryTarget,
+            JSON.stringify(args),
+            JSON.stringify(typeArgs),
+          ],
+      queryFn: async () => {
+        return await this.suiKit.inspectTxn(txBytes);
+      },
+      staleTime: 8000, // make stale time longer for inspectTxn results
+    });
+    return query;
+  }
+
+  /**
+   * @description Provides cache for getObject of the SuiKit.
+   * @param objectId
+   * @param QueryObjectParams
+   * @returns Promise<SuiObjectResponse>
+   */
+  public async queryGetObject(
+    objectId: string,
+    options?: SuiObjectDataOptions
+  ): Promise<SuiObjectResponse> {
+    const queryKey = ['getObject', objectId, this.suiKit.currentAddress()];
+    if (options) {
+      queryKey.push(JSON.stringify(options));
+    }
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        return await this.suiKit.client().getObject({
+          id: objectId,
+          options,
+        });
+      },
+    });
+  }
+
+  /**
+   * @description Provides cache for getObjects of the SuiKit.
+   * @param objectIds
+   * @returns Promise<SuiObjectData[]>
+   */
+  public async queryGetObjects(
+    objectIds: string[],
+    options?: SuiObjectDataOptions
+  ): Promise<SuiObjectData[]> {
+    const queryKey = [
+      'getObjects',
+      JSON.stringify(objectIds),
+      this.suiKit.currentAddress(),
+    ];
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        return await this.suiKit.getObjects(objectIds, options);
+      },
+    });
+  }
+
+  /**
+   * @description Provides cache for getOwnedObjects of the SuiKit.
+   * @param input
+   * @returns Promise<PaginatedObjectsResponse>
+   */
+  public async queryGetOwnedObjects(
+    input: GetOwnedObjectsParams
+  ): Promise<PaginatedObjectsResponse> {
+    const queryKey = ['getOwnedObjects', input.owner];
+    if (input.cursor) {
+      queryKey.push(JSON.stringify(input.cursor));
+    }
+    if (input.options) {
+      queryKey.push(JSON.stringify(input.options));
+    }
+    if (input.filter) {
+      queryKey.push(JSON.stringify(input.filter));
+    }
+    if (input.limit) {
+      queryKey.push(JSON.stringify(input.limit));
+    }
+
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        return await this.suiKit.client().getOwnedObjects(input);
+      },
+    });
+  }
+
+  public async queryGetDynamicFields(
+    input: GetDynamicFieldsParams
+  ): Promise<DynamicFieldPage> {
+    const queryKey = ['getDynamicFields', input.parentId];
+    if (input.cursor) {
+      queryKey.push(JSON.stringify(input.cursor));
+    }
+    if (input.cursor) {
+      queryKey.push(JSON.stringify(input.cursor));
+    }
+    if (input.limit) {
+      queryKey.push(JSON.stringify(input.limit));
+    }
+
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        return await this.suiKit.client().getDynamicFields(input);
+      },
+    });
+  }
+
+  public async queryGetDynamicFieldObject(
+    input: GetDynamicFieldObjectParams
+  ): Promise<SuiObjectResponse> {
+    const queryKey = [
+      'getDynamicFieldObject',
+      input.parentId,
+      input.name.value,
+    ];
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        return await this.suiKit.client().getDynamicFieldObject(input);
+      },
+    });
+  }
+}

package/src/models/scallopClient.ts

@@ -24,6 +24,8 @@ import type {
   SupportBorrowIncentiveCoins,
   ScallopTxBlock,
 } from '../types';
+import { ScallopCache } from './scallopCache';
+import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 
 /**
  * @description
@@ -45,6 +47,7 @@ export class ScallopClient {
   public builder: ScallopBuilder;
   public query: ScallopQuery;
   public utils: ScallopUtils;
+  public cache: ScallopCache;
   public walletAddress: string;
 
   public constructor(
@@ -53,17 +56,23 @@ export class ScallopClient {
   ) {
     this.params = params;
     this.suiKit = instance?.suiKit ?? new SuiKit(params);
+    this.cache =
+      instance?.cache ?? new ScallopCache(DEFAULT_CACHE_OPTIONS, this.suiKit);
     this.address =
       instance?.address ??
-      new ScallopAddress({
-        id: params?.addressesId || ADDRESSES_ID,
-        network: params?.networkType,
-      });
+      new ScallopAddress(
+        {
+          id: params?.addressesId || ADDRESSES_ID,
+          network: params?.networkType,
+        },
+        this.cache
+      );
     this.query =
       instance?.query ??
       new ScallopQuery(params, {
         suiKit: this.suiKit,
         address: this.address,
+        cache: this.cache,
       });
     this.utils =
       instance?.utils ??
@@ -71,6 +80,7 @@ export class ScallopClient {
         suiKit: this.suiKit,
         address: this.address,
         query: this.query,
+        cache: this.cache,
       });
     this.builder =
       instance?.builder ??
@@ -79,6 +89,7 @@ export class ScallopClient {
         address: this.address,
         query: this.query,
         utils: this.utils,
+        cache: this.cache,
       });
     this.walletAddress = normalizeSuiAddress(
       params?.walletAddress || this.suiKit.currentAddress()

package/src/models/scallopIndexer.ts

@@ -15,7 +15,11 @@ import type {
   SupportStakeMarketCoins,
   SupportBorrowIncentiveCoins,
   TotalValueLocked,
+  ScallopQueryParams,
+  ScallopParams,
+  ScallopInstanceParams,
 } from '../types';
+import { ScallopCache } from './scallopCache';
 
 /**
  * @description
@@ -30,9 +34,13 @@ import type {
  * ```
  */
 export class ScallopIndexer {
-  private _requestClient: AxiosInstance;
+  private readonly _cache: ScallopCache;
+  public readonly params: ScallopQueryParams;
+  private readonly _requestClient: AxiosInstance;
 
-  public constructor() {
+  public constructor(params: ScallopParams, instance?: ScallopInstanceParams) {
+    this.params = params;
+    this._cache = instance?.cache ?? new ScallopCache();
     this._requestClient = axios.create({
       baseURL: SDK_API_BASE_URL,
       headers: {
@@ -49,10 +57,15 @@ export class ScallopIndexer {
    * @return Market data.
    */
   public async getMarket(): Promise<Pick<Market, 'pools' | 'collaterals'>> {
-    const response = await this._requestClient.get<{
-      pools: MarketPool[];
-      collaterals: MarketCollateral[];
-    }>(`${SDK_API_BASE_URL}/api/market`);
+    const response = await this._cache.queryClient.fetchQuery({
+      queryKey: ['market'],
+      queryFn: async () => {
+        return await this._requestClient.get<{
+          pools: MarketPool[];
+          collaterals: MarketCollateral[];
+        }>(`/api/market`);
+      },
+    });
 
     if (response.status === 200) {
       return {
@@ -79,18 +92,8 @@ export class ScallopIndexer {
    * @return Market pools data.
    */
   public async getMarketPools(): Promise<Required<MarketPools>> {
-    const response = await this._requestClient.get<{
-      pools: MarketPool[];
-    }>(`${SDK_API_BASE_URL}/api/market/pools`);
-
-    if (response.status === 200) {
-      return response.data.pools.reduce((marketPools, marketPool) => {
-        marketPools[marketPool.coinName] = marketPool;
-        return marketPools;
-      }, {} as MarketPools) as Required<MarketPools>;
-    } else {
-      throw Error('Failed to getMarketPools.');
-    }
+    const response = (await this.getMarket()).pools;
+    return response as Required<MarketPools>;
   }
 
   /**
@@ -101,15 +104,7 @@ export class ScallopIndexer {
   public async getMarketPool(
     poolCoinName: SupportPoolCoins
   ): Promise<MarketPool> {
-    const response = await this._requestClient.get<{
-      pool: MarketPool;
-    }>(`${SDK_API_BASE_URL}/api/market/pool/${poolCoinName}`);
-
-    if (response.status === 200) {
-      return response.data.pool;
-    } else {
-      throw Error('Failed to getMarketPool.');
-    }
+    return (await this.getMarketPools())[poolCoinName] as MarketPool;
   }
 
   /**
@@ -118,21 +113,7 @@ export class ScallopIndexer {
    * @return Market collaterals data.
    */
   public async getMarketCollaterals(): Promise<Required<MarketCollaterals>> {
-    const response = await this._requestClient.get<{
-      collaterals: MarketCollateral[];
-    }>(`${SDK_API_BASE_URL}/api/market/collaterals`);
-
-    if (response.status === 200) {
-      return response.data.collaterals.reduce(
-        (marketCollaterals, marketCollateral) => {
-          marketCollaterals[marketCollateral.coinName] = marketCollateral;
-          return marketCollaterals;
-        },
-        {} as MarketCollaterals
-      ) as Required<MarketCollaterals>;
-    } else {
-      throw Error('Failed to getMarketCollaterals.');
-    }
+    return (await this.getMarket()).collaterals as Required<MarketCollaterals>;
   }
 
   /**
@@ -143,15 +124,9 @@ export class ScallopIndexer {
   public async getMarketCollateral(
     collateralCoinName: SupportCollateralCoins
   ): Promise<MarketCollateral> {
-    const response = await this._requestClient.get<{
-      collateral: MarketCollateral;
-    }>(`${SDK_API_BASE_URL}/api/market/collateral/${collateralCoinName}`);
-
-    if (response.status === 200) {
-      return response.data.collateral;
-    } else {
-      throw Error('Failed to getMarketCollateral.');
-    }
+    return (await this.getMarketCollaterals())[
+      collateralCoinName
+    ] as MarketCollateral;
   }
 
   /**
@@ -160,9 +135,14 @@ export class ScallopIndexer {
    * @return Spools data.
    */
   public async getSpools(): Promise<Required<Spools>> {
-    const response = await this._requestClient.get<{
-      spools: Spool[];
-    }>(`${SDK_API_BASE_URL}/api/spools`);
+    const response = await this._cache.queryClient.fetchQuery({
+      queryKey: ['spools'],
+      queryFn: async () => {
+        return await this._requestClient.get<{
+          spools: Spool[];
+        }>(`/api/spools`);
+      },
+    });
 
     if (response.status === 200) {
       return response.data.spools.reduce((spools, spool) => {
@@ -182,15 +162,7 @@ export class ScallopIndexer {
   public async getSpool(
     marketCoinName: SupportStakeMarketCoins
   ): Promise<Spool> {
-    const response = await this._requestClient.get<{
-      spool: Spool;
-    }>(`${SDK_API_BASE_URL}/api/spool/${marketCoinName}`);
-
-    if (response.status === 200) {
-      return response.data.spool;
-    } else {
-      throw Error('Failed to getSpool.');
-    }
+    return (await this.getSpools())[marketCoinName] as Spool;
   }
 
   /**
@@ -201,9 +173,14 @@ export class ScallopIndexer {
   public async getBorrowIncentivePools(): Promise<
     Required<BorrowIncentivePools>
   > {
-    const response = await this._requestClient.get<{
-      borrowIncentivePools: BorrowIncentivePool[];
-    }>(`${SDK_API_BASE_URL}/api/borrowIncentivePools`);
+    const response = await this._cache.queryClient.fetchQuery({
+      queryKey: ['borrowIncentivePools'],
+      queryFn: async () => {
+        return await this._requestClient.get<{
+          borrowIncentivePools: BorrowIncentivePool[];
+        }>(`/api/borrowIncentivePools`);
+      },
+    });
 
     if (response.status === 200) {
       return response.data.borrowIncentivePools.reduce(
@@ -227,17 +204,9 @@ export class ScallopIndexer {
   public async getBorrowIncentivePool(
     borrowIncentiveCoinName: SupportBorrowIncentiveCoins
   ): Promise<BorrowIncentivePool> {
-    const response = await this._requestClient.get<{
-      borrowIncentivePool: BorrowIncentivePool;
-    }>(
-      `${SDK_API_BASE_URL}/api/borrowIncentivePool/${borrowIncentiveCoinName}`
-    );
-
-    if (response.status === 200) {
-      return response.data.borrowIncentivePool;
-    } else {
-      throw Error('Failed to getSpool.');
-    }
+    return (await this.getBorrowIncentivePools())[
+      borrowIncentiveCoinName
+    ] as BorrowIncentivePool;
   }
 
   /**
@@ -252,13 +221,18 @@ export class ScallopIndexer {
       supplyValueChangeRatio: number;
     }
   > {
-    const response = await this._requestClient.get<
-      TotalValueLocked & {
-        totalValueChangeRatio: number;
-        borrowValueChangeRatio: number;
-        supplyValueChangeRatio: number;
-      }
-    >(`${SDK_API_BASE_URL}/api/market/tvl`);
+    const response = await this._cache.queryClient.fetchQuery({
+      queryKey: ['totalValueLocked'],
+      queryFn: async () => {
+        return await this._requestClient.get<
+          TotalValueLocked & {
+            totalValueChangeRatio: number;
+            borrowValueChangeRatio: number;
+            supplyValueChangeRatio: number;
+          }
+        >(`/api/market/tvl`);
+      },
+    });
 
     if (response.status === 200) {
       return response.data;

package/src/models/scallopQuery.ts

@@ -25,6 +25,8 @@ import {
   getObligationAccounts,
   getObligationAccount,
   getTotalValueLocked,
+  getBindedObligationId,
+  getBindedVeScaKey,
 } from '../queries';
 import {
   ScallopQueryParams,
@@ -41,6 +43,8 @@ import {
 import { ScallopAddress } from './scallopAddress';
 import { ScallopUtils } from './scallopUtils';
 import { ScallopIndexer } from './scallopIndexer';
+import { ScallopCache } from './scallopCache';
+import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 
 /**
  * @description
@@ -61,6 +65,7 @@ export class ScallopQuery {
   public address: ScallopAddress;
   public utils: ScallopUtils;
   public indexer: ScallopIndexer;
+  public cache: ScallopCache;
 
   public constructor(
     params: ScallopQueryParams,
@@ -68,20 +73,26 @@ export class ScallopQuery {
   ) {
     this.params = params;
     this.suiKit = instance?.suiKit ?? new SuiKit(params);
+    this.cache =
+      instance?.cache ?? new ScallopCache(DEFAULT_CACHE_OPTIONS, this.suiKit);
     this.address =
       instance?.address ??
-      new ScallopAddress({
-        id: params?.addressesId || ADDRESSES_ID,
-        network: params?.networkType,
-      });
+      new ScallopAddress(
+        {
+          id: params?.addressesId || ADDRESSES_ID,
+          network: params?.networkType,
+        },
+        this.cache
+      );
     this.utils =
       instance?.utils ??
       new ScallopUtils(this.params, {
         suiKit: this.suiKit,
         address: this.address,
+        cache: this.cache,
         query: this,
       });
-    this.indexer = new ScallopIndexer();
+    this.indexer = new ScallopIndexer(this.params, { cache: this.cache });
   }
 
   /**
@@ -512,4 +523,22 @@ export class ScallopQuery {
   public async getTvl(indexer: boolean = false) {
     return await getTotalValueLocked(this, indexer);
   }
+
+  /**
+   * Get binded obligationId from a veScaKey if it exists.
+   * @param veScaKey
+   * @returns obligationId
+   */
+  public async getBindedObligationId(veScaKey: string) {
+    return await getBindedObligationId(this, veScaKey);
+  }
+
+  /**
+   * Get binded veSCA key from a obligationId if it exists.
+   * @param obligationId
+   * @returns veScaKey
+   */
+  public async getBindedVeScaKey(obligationId: string) {
+    return await getBindedVeScaKey(this, obligationId);
+  }
 }