@scallop-io/sui-scallop-sdk 2.3.2 → 2.3.5

package/package.json

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

package/src/constants/queryKeys.ts

@@ -74,10 +74,16 @@ export const queryKeys = {
     },
   },
   oracle: {
-    getPythLatestPriceFeeds: (priceIds: string[]) => [
+    getPythLatestPriceFeeds: (endpoint?: string, priceIds?: string[]) => [
       'oracle',
       'getPythPriceIds',
       priceIds,
+      endpoint,
+    ],
+    getCoinPrices: (priceIds: string[]) => [
+      'oracle',
+      'getCoinPrices',
+      priceIds,
     ],
   },
 };

package/src/models/scallopQuery.ts

@@ -60,7 +60,7 @@ import {
   queryObligation,
   queryVeScaKeyIdFromReferralBindings,
 } from 'src/queries';
-import { SuiObjectRef, SuiObjectData } from '@mysten/sui/dist/cjs/client';
+import { SuiObjectRef, SuiObjectData } from '@mysten/sui/client';
 import { SuiObjectArg } from '@scallop-io/sui-kit';
 import { ScallopQueryInterface } from './interface';
 

package/src/models/scallopSuiKit.ts

@@ -26,6 +26,7 @@ import { QueryKey } from '@tanstack/query-core';
 import ScallopQueryClient, {
   ScallopQueryClientParams,
 } from './scallopQueryClient';
+import { RateLimiter } from './rateLimiter';
 
 type QueryInspectTxnParams = {
   queryTarget: string;
@@ -65,62 +66,6 @@ const deepMergeObject = <T>(curr: T, update: T): T => {
   return result;
 };
 
-export class RateLimiter {
-  private tokens: number;
-  private lastRefillTime: number;
-  private readonly refillRate: number; // tokens per millisecond
-
-  constructor(private readonly capacity: number = 10) {
-    this.refillRate = this.capacity / 1000; // 10 tokens per second = 0.01 tokens/ms
-    this.tokens = this.capacity;
-    this.lastRefillTime = Date.now();
-  }
-
-  private refill() {
-    const now = Date.now();
-    const elapsed = now - this.lastRefillTime;
-    const newTokens = elapsed * this.refillRate;
-
-    this.tokens = Math.min(this.capacity, this.tokens + newTokens);
-    this.lastRefillTime = now;
-  }
-
-  private getTimeToNextToken(): number {
-    this.refill();
-
-    if (this.tokens >= 1) {
-      return 0;
-    }
-
-    // Calculate exact milliseconds needed for 1 full token
-    const deficit = 1 - this.tokens;
-    return Math.ceil(deficit / this.refillRate);
-  }
-
-  async acquireToken(): Promise<void> {
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const waitTime = this.getTimeToNextToken();
-
-      if (waitTime === 0) {
-        if (this.tokens >= 1) {
-          this.tokens -= 1;
-          return;
-        }
-        continue;
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, waitTime));
-      this.refill();
-    }
-  }
-
-  async execute<T>(fn: () => Promise<T>): Promise<T> {
-    await this.acquireToken();
-    return await fn();
-  }
-}
-
 class ScallopSuiKit extends ScallopQueryClient {
   public readonly suiKit: SuiKit;
   private _walletAddress: string;

package/src/models/scallopUtils.ts

@@ -16,7 +16,7 @@ import {
 } from 'src/constants';
 import { PriceFeed, SuiPriceServiceConnection } from '@pythnetwork/pyth-sui-js';
 import ScallopSuiKit, { ScallopSuiKitParams } from './scallopSuiKit';
-import { SuiObjectData } from '@mysten/sui/dist/cjs/client';
+import { SuiObjectData } from '@mysten/sui/client';
 import { queryObligation } from 'src/queries';
 import { ScallopUtilsInterface } from './interface';
 
@@ -521,25 +521,24 @@ class ScallopUtils implements ScallopUtilsInterface {
       ]),
     ] as string[]
   ) {
-    let coinPrices: CoinPrices = {};
+    const priceIdsMap = new Map(
+      coinNames.map((coinName) => [
+        coinName,
+        this.address.get(`core.coins.${coinName}.oracle.pyth.feed`),
+      ])
+    );
 
-    const endpoints = this.pythEndpoints;
-    const failedRequests: Set<string> = new Set(coinNames);
-
-    for (const endpoint of endpoints) {
-      const priceIdPairs = Array.from(failedRequests.values()).reduce(
-        (acc, coinName) => {
-          const priceId =
-            this.address.get(`core.coins.${coinName}.oracle.pyth.feed`) ??
-            this.constants.poolAddresses[coinName]?.pythFeed;
-          acc.push([coinName, priceId]);
-          return acc;
-        },
-        [] as [string, string][]
-      );
-      if (priceIdPairs.length === 0) break;
+    const priceIds = Array.from(priceIdsMap.values());
+    const state = this.queryClient.getQueryState(
+      queryKeys.oracle.getCoinPrices(priceIds)
+    );
 
-      const priceIds = priceIdPairs.map(([_, priceId]) => priceId);
+    if (state && state && Date.now() - (state.dataUpdatedAt ?? 0) < 30_000) {
+      return state.data as CoinPrices;
+    }
+
+    let coinPrices: CoinPrices = {};
+    for (const endpoint of this.pythEndpoints) {
       const pythConnection = new SuiPriceServiceConnection(endpoint, {
         timeout: this.timeout,
         httpRetries: 0,
@@ -547,33 +546,49 @@ class ScallopUtils implements ScallopUtilsInterface {
 
       try {
         const feeds = await this.queryClient.fetchQuery({
-          queryKey: queryKeys.oracle.getPythLatestPriceFeeds(priceIds),
+          queryKey: queryKeys.oracle.getPythLatestPriceFeeds(
+            endpoint,
+            priceIds
+          ),
           queryFn: async () => {
             return await pythConnection.getLatestPriceFeeds(priceIds);
           },
-          staleTime: 30000,
-          gcTime: 30000,
+          retry: false,
+          staleTime: 30_000,
+          gcTime: 30_000,
         });
-        if (feeds) {
-          feeds.forEach((feed, idx) => {
-            const coinName = priceIdPairs[idx][0] as string;
-            const data = this.parseDataFromPythPriceFeed(feed);
-            coinPrices[coinName as string] = data.price;
-            failedRequests.delete(coinName as string); // remove success price feed to prevent duplicate request on the next endpoint
-          });
-        }
+        if (!feeds) throw new Error('No feeds returned from pyth');
+
+        if (feeds.length !== priceIds.length)
+          throw new Error('Incomplete feeds returned from pyth');
+
+        feeds.forEach((feed, idx) => {
+          const coinName = coinNames[idx] as string;
+          const data = this.parseDataFromPythPriceFeed(feed);
+          coinPrices[coinName as string] = data.price;
+        });
+        this.queryClient.setQueryData(
+          queryKeys.oracle.getCoinPrices(priceIds),
+          coinPrices
+        );
       } catch (e: any) {
+        if ('status' in e && e.status === 403) {
+          console.log(`trying next pyth endpoint`);
+          continue; // try next endpoint
+        }
         console.error(e.message);
       }
-      if (failedRequests.size === 0) break;
     }
 
-    if (failedRequests.size > 0) {
+    if (Object.keys(coinPrices).length === 0) {
       coinPrices = {
         ...coinPrices,
-        ...(await this.getPythPrices(Array.from(failedRequests.values()))),
+        ...(await this.getPythPrices(Array.from(coinNames))),
       };
-      failedRequests.clear();
+      this.queryClient.setQueryData(
+        queryKeys.oracle.getCoinPrices(priceIds),
+        coinPrices
+      );
     }
 
     return coinPrices;

package/src/types/constant/queryKeys.ts

@@ -4,7 +4,7 @@ import type {
   GetOwnedObjectsParams,
   SuiObjectData,
   SuiObjectDataOptions,
-} from '@mysten/sui/dist/cjs/client';
+} from '@mysten/sui/client';
 import type { SuiObjectArg, SuiTxArg } from '@scallop-io/sui-kit';
 
 export namespace QueryKeys {