@scallop-io/sui-scallop-sdk 1.4.1 → 1.4.2-rc.1

package/src/types/query/core.ts

@@ -28,7 +28,7 @@ export type BalanceSheet = {
   revenue: string;
 };
 
-export type BorrowIndex = {
+export type BorrowDynamic = {
   borrow_index: string;
   interest_rate: {
     fields: {
@@ -39,6 +39,8 @@ export type BorrowIndex = {
   last_updated: string;
 };
 
+export type BorrowFee = { value: string };
+
 export type InterestModel = {
   base_borrow_rate_per_sec: {
     fields: {
@@ -161,7 +163,7 @@ export type MarketCollateral = {
     | 'collateralFactor'
     | 'liquidationFactor'
     | 'liquidationDiscount'
-    | 'liquidationPanelty'
+    | 'liquidationPenalty'
     | 'liquidationReserveFactor'
   >
 > &
@@ -187,6 +189,9 @@ export type OriginMarketPoolData = {
   highKink: { value: string };
   midKink: { value: string };
   minBorrowAmount: string;
+  isIsolated: boolean;
+  supplyLimit: string;
+  borrowLimit: string;
 };
 
 export type ParsedMarketPoolData = {
@@ -209,6 +214,9 @@ export type ParsedMarketPoolData = {
   highKink: number;
   midKink: number;
   minBorrowAmount: number;
+  isIsolated: boolean;
+  supplyLimit: number;
+  borrowLimit: number;
 };
 
 export type CalculatedMarketPoolData = {
@@ -218,6 +226,8 @@ export type CalculatedMarketPoolData = {
   borrowApyOnHighKink: number;
   borrowAprOnMidKink: number;
   borrowApyOnMidKink: number;
+  coinDecimal: number;
+  conversionRate: number;
   maxBorrowApr: number;
   maxBorrowApy: number;
   borrowApr: number;
@@ -233,15 +243,18 @@ export type CalculatedMarketPoolData = {
   utilizationRate: number;
   supplyApr: number;
   supplyApy: number;
-  conversionRate: number;
+  isIsolated: boolean;
+  maxSupplyCoin: number;
+  maxBorrowCoin: number;
 };
 
 export type OriginMarketCollateralData = {
   type: { name: string };
+  isIsolated: boolean;
   collateralFactor: { value: string };
   liquidationFactor: { value: string };
   liquidationDiscount: { value: string };
-  liquidationPanelty: { value: string };
+  liquidationPenalty: { value: string };
   liquidationReserveFactor: { value: string };
   maxCollateralAmount: string;
   totalCollateralAmount: string;
@@ -252,13 +265,16 @@ export type ParsedMarketCollateralData = {
   collateralFactor: number;
   liquidationFactor: number;
   liquidationDiscount: number;
-  liquidationPanelty: number;
+  liquidationPenalty: number;
   liquidationReserveFactor: number;
   maxCollateralAmount: number;
   totalCollateralAmount: number;
+  isIsolated: boolean;
 };
 
 export type CalculatedMarketCollateralData = {
+  coinDecimal: number;
+  isIsolated: boolean;
   maxDepositAmount: number;
   maxDepositCoin: number;
   depositAmount: number;

package/src/types/query/spool.ts

@@ -37,6 +37,27 @@ export type OriginSpoolData = {
   lastUpdate: string;
 };
 
+export type SpoolData = {
+  created_at: string;
+  distributed_point: string;
+  distributed_point_per_period: string;
+  id: {
+    id: string;
+  };
+  index: string;
+  last_update: string;
+  max_distributed_point: string;
+  max_stakes: string;
+  point_distribution_time: string;
+  stake_type: {
+    type: string;
+    fields: {
+      name: string;
+    };
+  };
+  stakes: string;
+};
+
 export type ParsedSpoolData = {
   stakeType: string;
   maxPoint: number;

package/src/types/utils.ts

@@ -11,10 +11,15 @@ export type PoolAddressInfo = {
   coingeckoId: string;
   decimal: number;
   pythFeedId: string;
-  lendingPoolAddress: string;
-  collateralPoolAddress?: string;
+  lendingPoolAddress?: string;
+  collateralPoolAddress?: string; // not all pool has collateral
+  borrowDynamic?: string;
+  interestModelId?: string;
+  borrowFeeKey?: string;
+  supplyLimitKey?: string;
+  borrowLimitKey?: string;
+  isolatedAssetKey?: string;
   sCoinAddress: string | undefined;
   marketCoinAddress: string;
-  coinAddress: string;
   sCoinName: string | undefined;
 };

package/src/utils/core.ts

@@ -0,0 +1,18 @@
+import { SuiObjectData } from '@mysten/sui/client';
+
+export const parseObjectAs = <T>(object: SuiObjectData): T => {
+  if (!(object && object.content && 'fields' in object.content))
+    throw new Error(`Failed to parse object`);
+
+  const fields = object.content.fields as any;
+
+  if (typeof fields === 'object' && 'value' in fields) {
+    const value = fields.value;
+    if (typeof value === 'object' && 'fields' in value)
+      return value.fields as T;
+    return value as T;
+  } else if (typeof fields === 'object') {
+    return fields as T;
+  }
+  return fields as T;
+};

package/src/utils/index.ts

@@ -3,3 +3,5 @@ export * from './query';
 export * from './util';
 export * from './tokenBucket';
 export * from './indexer';
+export * from './core';
+export * from './tokenBucket';

package/src/utils/query.ts

@@ -62,6 +62,9 @@ export const parseOriginMarketPoolData = (
     highKink: Number(originMarketPoolData.highKink.value) / 2 ** 32,
     midKink: Number(originMarketPoolData.midKink.value) / 2 ** 32,
     minBorrowAmount: Number(originMarketPoolData.minBorrowAmount),
+    isIsolated: originMarketPoolData.isIsolated,
+    supplyLimit: Number(originMarketPoolData.supplyLimit),
+    borrowLimit: Number(originMarketPoolData.borrowLimit),
   };
 };
 
@@ -142,6 +145,7 @@ export const calculateMarketPoolData = (
     borrowApyOnHighKink: utils.parseAprToApy(borrowAprOnHighKink),
     borrowAprOnMidKink,
     borrowApyOnMidKink: utils.parseAprToApy(borrowAprOnMidKink),
+    coinDecimal,
     maxBorrowApr,
     maxBorrowApy: utils.parseAprToApy(maxBorrowApr),
     borrowApr: Math.min(borrowApr, maxBorrowApr),
@@ -161,6 +165,13 @@ export const calculateMarketPoolData = (
     supplyApr: supplyApr.toNumber(),
     supplyApy: utils.parseAprToApy(supplyApr.toNumber()),
     conversionRate: conversionRate.toNumber(),
+    isIsolated: parsedMarketPoolData.isIsolated,
+    maxSupplyCoin: BigNumber(parsedMarketPoolData.supplyLimit)
+      .shiftedBy(coinDecimal)
+      .toNumber(),
+    maxBorrowCoin: BigNumber(parsedMarketPoolData.borrowLimit)
+      .shiftedBy(coinDecimal)
+      .toNumber(),
   };
 };
 
@@ -176,14 +187,15 @@ export const parseOriginMarketCollateralData = (
   const divisor = 2 ** 32;
   return {
     coinType: normalizeStructTag(originMarketCollateralData.type.name),
+    isIsolated: originMarketCollateralData.isIsolated,
     collateralFactor:
       Number(originMarketCollateralData.collateralFactor.value) / divisor,
     liquidationFactor:
       Number(originMarketCollateralData.liquidationFactor.value) / divisor,
     liquidationDiscount:
       Number(originMarketCollateralData.liquidationDiscount.value) / divisor,
-    liquidationPanelty:
-      Number(originMarketCollateralData.liquidationPanelty.value) / divisor,
+    liquidationPenalty:
+      Number(originMarketCollateralData.liquidationPenalty.value) / divisor,
     liquidationReserveFactor:
       Number(originMarketCollateralData.liquidationReserveFactor.value) /
       divisor,
@@ -212,6 +224,8 @@ export const calculateMarketCollateralData = (
   ).shiftedBy(-1 * coinDecimal);
 
   return {
+    coinDecimal,
+    isIsolated: parsedMarketCollateralData.isIsolated,
     maxDepositAmount: parsedMarketCollateralData.maxCollateralAmount,
     maxDepositCoin: maxCollateralCoin.toNumber(),
     depositAmount: parsedMarketCollateralData.totalCollateralAmount,
@@ -423,6 +437,7 @@ export const parseOriginBorrowIncentivesPoolPointData = (
  * @return Parsed borrow incentive pool data
  */
 export const parseOriginBorrowIncentivePoolData = (
+  utils: ScallopUtils,
   originBorrowIncentivePoolData: OriginBorrowIncentivePoolData
 ): ParsedBorrowIncentivePoolData => {
   return {
@@ -433,9 +448,10 @@ export const parseOriginBorrowIncentivePoolData = (
     poolPoints: originBorrowIncentivePoolData.points.reduce(
       (acc, point) => {
         const parsed = parseOriginBorrowIncentivesPoolPointData(point);
-        const name = parseStructTag(
-          parsed.pointType
-        ).name.toLowerCase() as SupportBorrowIncentiveRewardCoins;
+        const name = utils.parseSCoinTypeNameToMarketCoinName(
+          parseStructTag(parsed.pointType).name.toLowerCase()
+        ) as SupportBorrowIncentiveRewardCoins;
+
         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;
     }
   }
 
@@ -39,41 +42,18 @@ const callWithRateLimit = async <T>(
   fn: () => Promise<T>,
   retryDelayInMs = DEFAULT_INTERVAL_IN_MS,
   maxRetries = 15,
-  backoffFactor = 2 // The factor by which to increase the delay
+  backoffFactor = 1.25 // The factor by which to increase the delay
 ): Promise<T | null> => {
   let retries = 0;
 
   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 {

package/src/utils/util.ts

@@ -127,3 +127,11 @@ export const findClosestUnlockRound = (unlockAtInSecondTimestamp: number) => {
   }
   return Math.floor(closestTwelveAM.getTime() / 1000);
 };
+
+export const partitionArray = <T>(array: T[], chunkSize: number) => {
+  const result: T[][] = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+};