@scallop-io/sui-scallop-sdk 1.4.1 → 1.4.12

package/dist/models/scallopQuery.d.ts

@@ -306,7 +306,7 @@ export declare class ScallopQuery {
      * @return Borrow incentive pools data.
      */
     getBorrowIncentivePools(coinNames?: SupportBorrowIncentiveCoins[], args?: {
-        coinPrices: CoinPrices;
+        coinPrices?: CoinPrices;
         indexer?: boolean;
         marketPools?: MarketPools;
     }): Promise<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "1.4.1",
+  "version": "1.4.12",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",

package/src/constants/testAddress.ts

@@ -236,6 +236,36 @@ export const TEST_ADDRESSES: AddressesInterface = {
           },
         },
       },
+      deep: {
+        id: '0xdeeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270',
+        metaData:
+          '0x6e60b051a08fa836f5a7acd7c464c8d9825bc29c44657fe170fe9b8e1e4770c0',
+        treasury: '',
+        oracle: {
+          supra: '',
+          switchboard: '',
+          pyth: {
+            feed: '29bdd5248234e33bd93d3b81100b5fa32eaa5997843847e2c2cb16d7c6d9f7ff',
+            feedObject:
+              '0x8c7f3a322b94cc69db2a2ac575cbd94bf5766113324c3a3eceac91e3e88a51ed',
+          },
+        },
+      },
+      fud: {
+        id: '0x76cb819b01abed502bee8a702b4c2d547532c12f25001c9dea795a5e631c26f1',
+        metaData:
+          '0x01087411ef48aaac1eb6e24803213e3a60a03b147dac930e5e341f17a85e524e',
+        treasury: '',
+        oracle: {
+          supra: '',
+          switchboard: '',
+          pyth: {
+            feed: '6a4090703da959247727f2b490eb21aea95c8684ecfac675f432008830890c75',
+            feedObject:
+              '0x4531c3ed0d22f21f5fce882905372006c9aafa30f01db03b789e95a6c50de7b2',
+          },
+        },
+      },
     },
     oracles: {
       xOracle:
@@ -513,6 +543,18 @@ export const TEST_ADDRESSES: AddressesInterface = {
         treasury:
           '0xfd0f02def6358a1f266acfa1493d4707ee8387460d434fb667d63d755ff907ed',
       },
+      sdeep: {
+        coinType:
+          '0xeb7a05a3224837c5e5503575aed0be73c091d1ce5e43aa3c3e716e0ae614608f::scallop_deep::SCALLOP_DEEP',
+        treasury:
+          '0xc63838fabe37b25ad897392d89876d920f5e0c6a406bf3abcb84753d2829bc88',
+      },
+      sfud: {
+        coinType:
+          '0xe56d5167f427cbe597da9e8150ef5c337839aaf46891d62468dcf80bdd8e10d1::scallop_fud::SCALLOP_FUD',
+        treasury:
+          '0xf25212f11d182decff7a86165699a73e3d5787aced203ca539f43cfbc10db867',
+      },
     },
   },
 };

package/src/constants/tokenBucket.ts

@@ -1,2 +1,2 @@
-export const DEFAULT_TOKENS_PER_INTERVAL = 50;
-export const DEFAULT_INTERVAL_IN_MS = 100;
+export const DEFAULT_TOKENS_PER_INTERVAL = 10;
+export const DEFAULT_INTERVAL_IN_MS = 50;

package/src/models/scallopCache.ts

@@ -122,10 +122,13 @@ export class ScallopCache {
     txBlock.moveCall(queryTarget, args, typeArgs);
 
     const query = await this.queryClient.fetchQuery({
+      retry: 5,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getInspectTxn(queryTarget, args, typeArgs),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
-          this.suiKit.inspectTxn(txBlock)
+        return await callWithRateLimit(
+          this.tokenBucket,
+          async () => await this.suiKit.inspectTxn(txBlock)
         );
       },
     });
@@ -143,13 +146,17 @@ export class ScallopCache {
     options?: SuiObjectDataOptions
   ): Promise<SuiObjectResponse | null> {
     return this.queryClient.fetchQuery({
+      retry: 5,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getObject(objectId, this.walletAddress, options),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
-          this.client.getObject({
-            id: objectId,
-            options,
-          })
+        return await callWithRateLimit(
+          this.tokenBucket,
+          async () =>
+            await this.client.getObject({
+              id: objectId,
+              options,
+            })
         );
       },
     });
@@ -170,14 +177,17 @@ export class ScallopCache {
     // objectIds.sort();
 
     return this.queryClient.fetchQuery({
+      retry: 5,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getObjects(
         objectIds,
         this.walletAddress,
         options
       ),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
-          this.suiKit.getObjects(objectIds, options)
+        return await callWithRateLimit(
+          this.tokenBucket,
+          async () => await this.suiKit.getObjects(objectIds, options)
         );
       },
     });
@@ -190,10 +200,13 @@ export class ScallopCache {
    */
   public async queryGetOwnedObjects(input: GetOwnedObjectsParams) {
     return this.queryClient.fetchQuery({
+      retry: 5,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getOwnedObjects(input),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
-          this.client.getOwnedObjects(input)
+        return await callWithRateLimit(
+          this.tokenBucket,
+          async () => await this.client.getOwnedObjects(input)
         );
       },
     });
@@ -203,10 +216,13 @@ export class ScallopCache {
     input: GetDynamicFieldsParams
   ): Promise<DynamicFieldPage | null> {
     return this.queryClient.fetchQuery({
+      retry: 5,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getDynamicFields(input),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
-          this.client.getDynamicFields(input)
+        return await callWithRateLimit(
+          this.tokenBucket,
+          async () => await this.client.getDynamicFields(input)
         );
       },
     });
@@ -216,6 +232,8 @@ export class ScallopCache {
     input: GetDynamicFieldObjectParams
   ): Promise<SuiObjectResponse | null> {
     return this.queryClient.fetchQuery({
+      retry: 5,
+      retryDelay: (attemptIndex) => Math.min(1000 * attemptIndex, 8000),
       queryKey: queryKeys.rpc.getDynamicFieldObject(input),
       queryFn: async () => {
         return await callWithRateLimit(this.tokenBucket, () =>
@@ -229,10 +247,13 @@ export class ScallopCache {
     owner: string
   ): Promise<{ [k: string]: string }> {
     return this.queryClient.fetchQuery({
+      retry: 5,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getAllCoinBalances(owner),
       queryFn: async () => {
-        const allBalances = await callWithRateLimit(this.tokenBucket, () =>
-          this.client.getAllBalances({ owner })
+        const allBalances = await callWithRateLimit(
+          this.tokenBucket,
+          async () => await this.client.getAllBalances({ owner })
         );
         if (!allBalances) return {};
         const balances = allBalances.reduce(

package/src/models/scallopQuery.ts

@@ -546,7 +546,7 @@ export class ScallopQuery {
   public async getBorrowIncentivePools(
     coinNames?: SupportBorrowIncentiveCoins[],
     args?: {
-      coinPrices: CoinPrices;
+      coinPrices?: CoinPrices;
       indexer?: boolean;
       marketPools?: MarketPools;
     }

package/src/models/scallopUtils.ts

@@ -553,7 +553,7 @@ export class ScallopUtils {
       const priceIds = priceIdPairs.map(([_, priceId]) => priceId);
 
       const pythConnection = new SuiPriceServiceConnection(endpoint, {
-        timeout: 2000,
+        timeout: 4000,
       });
 
       try {

package/src/queries/borrowLimitQuery.ts

@@ -19,6 +19,7 @@ const borrowLimitZod = zod.object({
 
 const borrowLimitKeyType = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::BorrowLimitKey`; // prod
 // const borrowLimitKeyType = `0xb784ea287d944e478a3ceaa071f8885072cce6b7224cf245914dc2f9963f460e::market_dynamic_keys::BorrowLimitKey`;
+
 /**
  * Return supply limit of a pool (including the decimals)
  * @param utils

package/src/queries/portfolioQuery.ts

@@ -25,6 +25,7 @@ import type {
   SupportBorrowIncentiveCoins,
   ObligationBorrowIcentiveReward,
   SupportBorrowIncentiveRewardCoins,
+  SupportAssetCoins,
 } from '../types';
 
 /**
@@ -349,15 +350,18 @@ export const getObligationAccount = async (
   coinPrices?: CoinPrices,
   coinAmounts?: CoinAmounts
 ) => {
-  const collateralAssetCoinNames: SupportCollateralCoins[] = [
+  const coinNames: SupportAssetCoins[] = Array.from(
+    new Set([...SUPPORT_POOLS, ...SUPPORT_COLLATERALS])
+  );
+  const collateralAssetCoinNames = [
     ...SUPPORT_COLLATERALS,
-  ];
+  ] as SupportCollateralCoins[];
+
   market = market ?? (await query.queryMarket({ indexer }));
   coinPrices =
     coinPrices ?? (await query.getAllCoinPrices({ marketPools: market.pools }));
   coinAmounts =
-    coinAmounts ||
-    (await query.getCoinAmounts(collateralAssetCoinNames, ownerAddress));
+    coinAmounts || (await query.getCoinAmounts(coinNames, ownerAddress));
 
   const [obligationQuery, borrowIncentivePools, borrowIncentiveAccounts] =
     await Promise.all([
@@ -365,6 +369,7 @@ export const getObligationAccount = async (
       query.getBorrowIncentivePools(undefined, {
         coinPrices,
         indexer,
+        marketPools: market.pools,
       }),
       query.getBorrowIncentiveAccounts(obligationId),
     ]);

package/src/utils/query.ts

@@ -27,6 +27,7 @@ import type {
   ParsedBorrowIncentiveAccountPoolData,
   SupportBorrowIncentiveRewardCoins,
 } from '../types';
+import { sCoinRawNameToName } from 'src/constants';
 
 /**
  *  Parse origin market pool data to a more readable format.
@@ -433,9 +434,12 @@ export const parseOriginBorrowIncentivePoolData = (
     poolPoints: originBorrowIncentivePoolData.points.reduce(
       (acc, point) => {
         const parsed = parseOriginBorrowIncentivesPoolPointData(point);
-        const name = parseStructTag(
+        let name = parseStructTag(
           parsed.pointType
         ).name.toLowerCase() as SupportBorrowIncentiveRewardCoins;
+        if (sCoinRawNameToName[name]) {
+          name = sCoinRawNameToName[name];
+        }
         acc[name] = parsed;
         return acc;
       },

package/src/utils/tokenBucket.ts

@@ -16,11 +16,14 @@ class TokenBucket {
   refill() {
     const now = Date.now();
     const elapsed = now - this.lastRefill;
-    if (elapsed > this.interval) {
+
+    if (elapsed >= this.interval) {
       const tokensToAdd =
         Math.floor(elapsed / this.interval) * this.tokensPerInterval;
       this.tokens = Math.min(this.tokens + tokensToAdd, this.tokensPerInterval);
-      this.lastRefill = now;
+
+      // Update lastRefill to reflect the exact time of the last "refill"
+      this.lastRefill += Math.floor(elapsed / this.interval) * this.interval;
     }
   }
 
@@ -45,35 +48,12 @@ const callWithRateLimit = async <T>(
 
   const tryRequest = async (): Promise<T | null> => {
     if (tokenBucket.removeTokens(1)) {
-      try {
-        const result = await fn();
-
-        // Check if the result is an object with status code (assuming the response has a status property)
-        if (result && (result as any).status === 429) {
-          throw new Error('Unexpected status code: 429');
-        }
-
-        return result;
-      } catch (error: any) {
-        if (
-          error.message === 'Unexpected status code: 429' &&
-          retries < maxRetries
-        ) {
-          retries++;
-          const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
-          // console.warn(`429 encountered, retrying in ${delay} ms`);
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          return tryRequest();
-        } else {
-          // console.error(error);
-          console.error('An error occurred:', error.message);
-          return null;
-        }
-      }
+      const result = await fn();
+      return result;
     } else if (retries < maxRetries) {
       retries++;
       const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
-      // console.warn(`Rate limit exceeded, retrying in ${delay} ms`);
+      console.error(`Rate limit exceeded, retrying in ${delay} ms`);
       await new Promise((resolve) => setTimeout(resolve, delay));
       return tryRequest();
     } else {