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

package/src/models/scallopCache.ts

@@ -1,8 +1,9 @@
-import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
+import { QueryClient } from '@tanstack/query-core';
 import {
   SuiObjectArg,
   SuiTxBlock,
   normalizeStructTag,
+  parseStructTag,
 } from '@scallop-io/sui-kit';
 import { SuiKit } from '@scallop-io/sui-kit';
 import type {
@@ -16,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;
@@ -31,6 +30,32 @@ type QueryInspectTxnParams = {
   typeArgs?: any[];
 };
 
+const DEFAULT_TOKENS_PER_INTERVAL = 10;
+const DEFAULT_INTERVAL_IN_MS = 250;
+
+const deepMergeObject = <T>(curr: T, update: T): T => {
+  const result = { ...curr }; // Clone the current object to avoid mutation
+
+  for (const key in update) {
+    if (
+      update[key] &&
+      typeof update[key] === 'object' &&
+      !Array.isArray(update[key])
+    ) {
+      // If the value is an object, recurse
+      result[key] = deepMergeObject(
+        curr[key] || ({} as T[Extract<keyof T, string>]),
+        update[key]
+      );
+    } else {
+      // Otherwise, directly assign the value
+      result[key] = update[key];
+    }
+  }
+
+  return result;
+};
+
 /**
  * @description
  * It provides caching for moveCall, RPC Request, and API Request.
@@ -45,20 +70,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) {
@@ -70,22 +101,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 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;
+    }
   }
 
-  private get suiKit(): SuiKit {
-    if (!this._suiKit) {
-      throw new Error('SuiKit instance is not initialized');
+  private removeTokens(count: number) {
+    this.refill();
+    if (this.tokens >= count) {
+      this.tokens -= count;
+      return true;
     }
-    return this._suiKit;
+    return false;
   }
 
-  private get client(): SuiClient {
-    return this.suiKit.client();
+  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();
   }
 
   /**
@@ -97,14 +168,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;
@@ -125,12 +196,39 @@ export class ScallopCache {
   }: QueryInspectTxnParams): Promise<DevInspectResults | null> {
     const txBlock = new SuiTxBlock();
 
+    const resolvedQueryTarget =
+      await this.queryGetNormalizedMoveFunction(queryTarget);
+    if (!resolvedQueryTarget) throw new Error('Invalid query target');
+
+    const { parameters } = resolvedQueryTarget;
+
     const resolvedArgs = await Promise.all(
-      args.map(async (arg) => {
-        if (typeof arg === 'string') {
-          return (await this.queryGetObject(arg))?.data;
-        }
-        return arg;
+      (args ?? []).map(async (arg, idx) => {
+        if (typeof arg !== 'string') return arg;
+
+        const cachedData = (await this.queryGetObject(arg))?.data;
+        if (!cachedData) return arg;
+
+        const owner = cachedData.owner;
+        if (!owner || typeof owner !== 'object' || !('Shared' in owner))
+          return {
+            objectId: cachedData.objectId,
+            version: cachedData.version,
+            digest: cachedData.digest,
+          };
+
+        const parameter = parameters[idx];
+        if (
+          typeof parameter !== 'object' ||
+          !('MutableReference' in parameter || 'Reference' in parameter)
+        )
+          return arg;
+
+        return {
+          objectId: cachedData.objectId,
+          initialSharedVersion: owner.Shared.initial_shared_version,
+          mutable: 'MutableReference' in parameter,
+        };
       })
     );
     txBlock.moveCall(queryTarget, resolvedArgs, typeArgs);
@@ -140,8 +238,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)
         );
       },
@@ -149,6 +246,23 @@ export class ScallopCache {
     return query;
   }
 
+  public async queryGetNormalizedMoveFunction(target: string) {
+    const { address, module, name } = parseStructTag(target);
+    return this.queryClient.fetchQuery({
+      queryKey: queryKeys.rpc.getNormalizedMoveFunction(target),
+      queryFn: async () => {
+        return await this.callWithRateLimit(
+          async () =>
+            await this.suiKit.client().getNormalizedMoveFunction({
+              package: address,
+              module,
+              function: name,
+            })
+        );
+      },
+    });
+  }
+
   /**
    * @description Provides cache for getObject of the SuiKit.
    * @param objectId
@@ -159,13 +273,18 @@ export class ScallopCache {
     objectId: string,
     options?: SuiObjectDataOptions
   ) {
+    options = {
+      ...options,
+      showOwner: true,
+      showContent: true,
+      showType: true,
+    };
     return this.queryClient.fetchQuery({
       retry: this.retryFn,
       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,
@@ -181,43 +300,38 @@ export class ScallopCache {
    * @param objectIds
    * @returns Promise<SuiObjectData[]>
    */
-  public async queryGetObjects(
-    objectIds: string[],
-    options: SuiObjectDataOptions = {
-      showContent: true,
-    }
-  ): Promise<SuiObjectData[]> {
+  public async queryGetObjects(objectIds: string[]): Promise<SuiObjectData[]> {
     if (objectIds.length === 0) return [];
-    // objectIds.sort();
+    const options: SuiObjectDataOptions = {
+      showContent: true,
+      showOwner: true,
+      showType: true,
+    };
 
     return this.queryClient.fetchQuery({
       retry: this.retryFn,
       retryDelay: 1000,
-      queryKey: queryKeys.rpc.getObjects(
-        objectIds,
-        this.walletAddress,
-        options
-      ),
+      queryKey: queryKeys.rpc.getObjects(objectIds),
       queryFn: async () => {
-        const results = await callWithRateLimit(
-          this.tokenBucket,
+        const results = await this.callWithRateLimit(
           async () => await this.suiKit.getObjects(objectIds, options)
         );
         if (results) {
           results.forEach((result) => {
-            this.queryClient.setQueriesData(
-              {
+            // fetch previous data
+            const queryKey = queryKeys.rpc.getObject(result.objectId);
+            const prevDatas =
+              this.queryClient.getQueriesData<SuiObjectResponse>({
                 exact: false,
-                queryKey: queryKeys.rpc.getObject(result.objectId, options),
-              },
-              {
-                data: result,
-                error: null,
-              },
-              {
-                updatedAt: Date.now(),
-              }
-            );
+                queryKey,
+              });
+            prevDatas.forEach(([key, prevData]) => {
+              this.queryClient.setQueryData(
+                key,
+                deepMergeObject(prevData, { data: result, error: null }),
+                { updatedAt: Date.now() }
+              );
+            });
           });
         }
         return results;
@@ -231,14 +345,13 @@ export class ScallopCache {
    * @returns Promise<PaginatedObjectsResponse>
    */
   public async queryGetOwnedObjects(input: GetOwnedObjectsParams) {
-    // TODO: This query need its own separate rate limiter (as owned objects can theoretically be infinite), need a better way to handle this
+    // @TODO: This query need its own separate rate limiter (as owned objects can theoretically be infinite), need a better way to handle this
     return this.queryClient.fetchQuery({
       retry: this.retryFn,
       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) {
@@ -250,22 +363,20 @@ export class ScallopCache {
                 NonNullable<{ data: SuiObjectData }> => !!result.data
             )
             .forEach((result) => {
-              this.queryClient.setQueriesData(
-                {
+              // fetch previous data
+              const queryKey = queryKeys.rpc.getObject(result.data.objectId);
+              const prevDatas =
+                this.queryClient.getQueriesData<SuiObjectResponse>({
                   exact: false,
-                  queryKey: queryKeys.rpc.getObject(
-                    result.data.objectId,
-                    input.options ?? {}
-                  ),
-                },
-                {
-                  data: result.data,
-                  error: null,
-                },
-                {
-                  updatedAt: Date.now(),
-                }
-              );
+                  queryKey,
+                });
+              prevDatas.forEach(([key, prevData]) => {
+                this.queryClient.setQueryData(
+                  key,
+                  deepMergeObject(prevData, { data: result.data, error: null }),
+                  { updatedAt: Date.now() }
+                );
+              });
             });
         }
         return results;
@@ -281,8 +392,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)
         );
       },
@@ -297,26 +407,22 @@ 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) {
-          this.queryClient.setQueriesData(
-            {
-              exact: false,
-              queryKey: queryKeys.rpc.getObject(result?.data.objectId, {
-                showContent: true,
-                showOwner: true,
-              }),
-            },
-            {
-              data: result.data,
-              error: null,
-            },
-            {
-              updatedAt: Date.now(),
-            }
-          );
+          const queryKey = queryKeys.rpc.getObject(result.data.objectId);
+          const prevDatas = this.queryClient.getQueriesData<SuiObjectResponse>({
+            exact: false,
+            queryKey,
+          });
+          prevDatas.forEach(([key, prevData]) => {
+            this.queryClient.setQueryData(
+              key,
+              deepMergeObject(prevData, { data: result.data, error: null }),
+              { updatedAt: Date.now() }
+            );
+          });
         }
         return result;
       },
@@ -325,26 +431,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;
@@ -352,8 +456,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,
@@ -58,7 +57,7 @@ export class ScallopClient {
   public walletAddress: string;
 
   public constructor(
-    params: ScallopClientParams,
+    params: ScallopClientParams = {},
     instance?: ScallopClientInstanceParams
   ) {
     this.params = params;
@@ -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';
 
 /**
@@ -44,13 +42,11 @@ export class ScallopIndexer {
   private readonly _requestClient: AxiosInstance;
 
   public constructor(
-    params: ScallopParams,
+    params: ScallopParams = {},
     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: {