@scallop-io/sui-scallop-sdk 0.44.28 → 0.46.0

package/src/models/scallopAddress.ts

@@ -1,4 +1,3 @@
-import axios, { AxiosInstance } from 'axios';
 import { API_BASE_URL } from '../constants';
 import type { NetworkType } from '@scallop-io/sui-kit';
 import type {
@@ -6,6 +5,9 @@ import type {
   AddressesInterface,
   AddressStringPath,
 } from '../types';
+import { ScallopCache } from './scallopCache';
+import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
+import axios, { AxiosInstance } from 'axios';
 
 const EMPTY_ADDRESSES: AddressesInterface = {
   core: {
@@ -17,6 +19,45 @@ const EMPTY_ADDRESSES: AddressesInterface = {
     coinDecimalsRegistry: '',
     obligationAccessStore: '',
     coins: {
+      cetus: {
+        id: '',
+        metaData: '',
+        treasury: '',
+        oracle: {
+          supra: '',
+          switchboard: '',
+          pyth: {
+            feed: '',
+            feedObject: '',
+          },
+        },
+      },
+      apt: {
+        id: '',
+        metaData: '',
+        treasury: '',
+        oracle: {
+          supra: '',
+          switchboard: '',
+          pyth: {
+            feed: '',
+            feedObject: '',
+          },
+        },
+      },
+      sol: {
+        id: '',
+        metaData: '',
+        treasury: '',
+        oracle: {
+          supra: '',
+          switchboard: '',
+          pyth: {
+            feed: '',
+            feedObject: '',
+          },
+        },
+      },
       btc: {
         id: '',
         metaData: '',
@@ -138,15 +179,8 @@ const EMPTY_ADDRESSES: AddressesInterface = {
     oracles: {
       xOracle: '',
       xOracleCap: '',
-      supra: {
-        registry: '',
-        registryCap: '',
-        holder: '',
-      },
-      switchboard: {
-        registry: '',
-        registryCap: '',
-      },
+      supra: { registry: '', registryCap: '', holder: '' },
+      switchboard: { registry: '', registryCap: '' },
       pyth: {
         registry: '',
         registryCap: '',
@@ -176,27 +210,25 @@ const EMPTY_ADDRESSES: AddressesInterface = {
         id: '',
         upgradeCap: '',
       },
-      query: {
+      protocolWhitelist: {
         id: '',
         upgradeCap: '',
       },
-      pyth: {
+      query: {
         id: '',
         upgradeCap: '',
       },
-      switchboard: {
+      supra: { id: '', upgradeCap: '' },
+      pyth: {
         id: '',
         upgradeCap: '',
       },
+      switchboard: { id: '', upgradeCap: '' },
       xOracle: {
         id: '',
         upgradeCap: '',
       },
-      // Deploy for faucet on testnet.
-      testCoin: {
-        id: '',
-        upgradeCap: '',
-      },
+      testCoin: { id: '', upgradeCap: '' },
     },
   },
   spool: {
@@ -237,26 +269,40 @@ const EMPTY_ADDRESSES: AddressesInterface = {
         rewardPoolId: '',
       },
     },
+    config: '',
   },
   borrowIncentive: {
     id: '',
     adminCap: '',
     object: '',
     query: '',
-    config: '',
     incentivePools: '',
     incentiveAccounts: '',
+    config: '',
   },
   vesca: {
     id: '',
+    object: '',
     adminCap: '',
     tableId: '',
     table: '',
     treasury: '',
     config: '',
   },
+  referral: {
+    id: '',
+    version: '',
+    object: '',
+    adminCap: '',
+    referralBindings: '',
+    bindingTableId: '',
+    referralRevenuePool: '',
+    revenueTableId: '',
+    referralTiers: '',
+    tiersTableId: '',
+    authorizedWitnessList: '',
+  },
 };
-
 /**
  * @description
  * It provides methods for managing addresses.
@@ -270,20 +316,17 @@ const EMPTY_ADDRESSES: AddressesInterface = {
  */
 export class ScallopAddress {
   private readonly _auth?: string;
+  private readonly _requestClient: AxiosInstance;
 
-  private _requestClient: AxiosInstance;
   private _id?: string;
   private _network: NetworkType;
   private _currentAddresses?: AddressesInterface;
   private _addressesMap: Map<NetworkType, AddressesInterface>;
+  private _cache: ScallopCache;
 
-  public constructor(params: ScallopAddressParams) {
+  public constructor(params: ScallopAddressParams, cache?: ScallopCache) {
     const { id, auth, network } = params;
-
-    if (auth) this._auth = auth;
-    this._id = id;
-    this._network = network || 'mainnet';
-    this._addressesMap = new Map();
+    this._cache = cache ?? new ScallopCache(DEFAULT_CACHE_OPTIONS);
     this._requestClient = axios.create({
       baseURL: API_BASE_URL,
       headers: {
@@ -292,6 +335,10 @@ export class ScallopAddress {
       },
       timeout: 30000,
     });
+    if (auth) this._auth = auth;
+    this._id = id;
+    this._network = network || 'mainnet';
+    this._addressesMap = new Map();
   }
 
   /**
@@ -437,7 +484,7 @@ export class ScallopAddress {
       this._addressesMap.clear();
       this.setAddresses(targetAddresses, targetNetwork);
       const response = await this._requestClient.post(
-        `${API_BASE_URL}/addresses`,
+        `/addresses`,
         JSON.stringify({ ...Object.fromEntries(this._addressesMap), memo }),
         {
           headers: {
@@ -475,14 +522,16 @@ export class ScallopAddress {
   public async read(id?: string) {
     const addressesId = id || this._id || undefined;
     if (addressesId !== undefined) {
-      const response = await this._requestClient.get(
-        `${API_BASE_URL}/addresses/${addressesId}`,
-        {
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        }
-      );
+      const response = await this._cache.queryClient.fetchQuery({
+        queryKey: ['api-getAddresses', addressesId],
+        queryFn: async () => {
+          return await this._requestClient.get(`/addresses/${addressesId}`, {
+            headers: {
+              'Content-Type': 'application/json',
+            },
+          });
+        },
+      });
 
       if (response.status === 200) {
         for (const [network, addresses] of Object.entries<AddressesInterface>(
@@ -548,7 +597,7 @@ export class ScallopAddress {
       }
       this.setAddresses(targetAddresses, targetNetwork);
       const response = await this._requestClient.put(
-        `${API_BASE_URL}/addresses/${targetId}`,
+        `/addresses/${targetId}`,
         JSON.stringify({ ...Object.fromEntries(this._addressesMap), memo }),
         {
           headers: {
@@ -592,7 +641,7 @@ export class ScallopAddress {
       throw Error('Require specific addresses id to be deleted.');
     if (apiKey !== undefined) {
       const response = await this._requestClient.delete(
-        `${API_BASE_URL}/addresses/${targetId}`,
+        `/addresses/${targetId}`,
         {
           headers: {
             'Content-Type': 'application/json',

package/src/models/scallopBuilder.ts

@@ -15,6 +15,8 @@ import type {
   SupportMarketCoins,
   SupportAssetCoins,
 } from '../types';
+import { ScallopCache } from './scallopCache';
+import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 
 /**
  * @description
@@ -36,6 +38,7 @@ export class ScallopBuilder {
   public query: ScallopQuery;
   public utils: ScallopUtils;
   public walletAddress: string;
+  public cache: ScallopCache;
 
   public constructor(
     params: ScallopBuilderParams,
@@ -43,17 +46,23 @@ export class ScallopBuilder {
   ) {
     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 ??
@@ -61,6 +70,7 @@ export class ScallopBuilder {
         suiKit: this.suiKit,
         address: this.address,
         query: this.query,
+        cache: this.cache,
       });
     this.walletAddress = normalizeSuiAddress(
       params?.walletAddress || this.suiKit.currentAddress()

package/src/models/scallopCache.ts

@@ -0,0 +1,285 @@
+import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
+import { SuiTxArg, SuiTxBlock, normalizeStructTag } from '@scallop-io/sui-kit';
+import { SuiKit } from '@scallop-io/sui-kit';
+import type {
+  SuiObjectResponse,
+  SuiObjectDataOptions,
+  SuiObjectData,
+  PaginatedObjectsResponse,
+  GetOwnedObjectsParams,
+  DevInspectResults,
+  GetDynamicFieldsParams,
+  DynamicFieldPage,
+  GetDynamicFieldObjectParams,
+  GetBalanceParams,
+} 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>
+   */
+  public 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);
+      },
+    });
+  }
+
+  public async queryGetAllCoinBalances(
+    owner: string
+  ): Promise<{ [k: string]: string }> {
+    const queryKey = ['getAllCoinBalances', owner];
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        const allBalances = await this.suiKit
+          .client()
+          .getAllBalances({ owner });
+        return allBalances.reduce(
+          (acc, coinBalance) => {
+            if (coinBalance.totalBalance !== '0') {
+              acc[normalizeStructTag(coinBalance.coinType)] =
+                coinBalance.totalBalance;
+            }
+            return acc;
+          },
+          {} as { [k: string]: string }
+        );
+      },
+    });
+  }
+
+  public async queryGetCoinBalance(input: GetBalanceParams): Promise<string> {
+    const queryKey = ['getCoinBalance', input.owner, input.coinType];
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        if (!input.coinType) return '0';
+        return (
+          (await this.queryGetAllCoinBalances(input.owner))[
+            normalizeStructTag(input.coinType)
+          ] ?? '0'
+        );
+      },
+    });
+  }
+}

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()