@scallop-io/sui-scallop-sdk 1.4.14-alpha.1 → 1.4.15-rc.1

package/src/queries/index.ts

@@ -10,3 +10,5 @@ export * from './spoolQuery';
 export * from './supplyLimitQuery';
 export * from './vescaQuery';
 export * from './borrowLimitQuery';
+export * from './poolAddressesQuery';
+export * from './objectsQuery';

package/src/queries/isolatedAssetQuery.ts

@@ -1,7 +1,8 @@
 import { DynamicFieldInfo, DynamicFieldName } from '@mysten/sui/client';
-import { ScallopAddress, ScallopUtils } from '../models';
+import { ScallopQuery, ScallopUtils } from '../models';
 import { SupportPoolCoins } from '../types';
 import { z as zod } from 'zod';
+import { POOL_ADDRESSES, SUPPORT_POOLS } from 'src/constants';
 
 const isolatedAssetZod = zod.object({
   dataType: zod.string(),
@@ -18,8 +19,8 @@ const isolatedAssetZod = zod.object({
   }),
 });
 
-// const isolatedAssetKeyType = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::IsolatedAssetKey`; // prod
-const isolatedAssetKeyType = `0x6c23585e940a989588432509107e98bae06dbca4e333f26d0635d401b3c7c76d::market_dynamic_keys::IsolatedAssetKey`;
+const isolatedAssetKeyType = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::IsolatedAssetKey`; // prod
+// const isolatedAssetKeyType = `0x6c23585e940a989588432509107e98bae06dbca4e333f26d0635d401b3c7c76d::market_dynamic_keys::IsolatedAssetKey`;
 
 /**
  * Return list of isolated assets coin types
@@ -27,10 +28,16 @@ const isolatedAssetKeyType = `0x6c23585e940a989588432509107e98bae06dbca4e333f26d
  * @returns list of isolated assets coin types
  */
 export const getIsolatedAssets = async (
-  address: ScallopAddress
+  query: ScallopQuery
 ): Promise<string[]> => {
+  if (SUPPORT_POOLS.every((t) => !!POOL_ADDRESSES[t])) {
+    return SUPPORT_POOLS.filter(
+      (t): t is typeof t & { coinType: string; isolatedAssetKey: string } =>
+        !!POOL_ADDRESSES[t]?.isolatedAssetKey && !!POOL_ADDRESSES[t]?.coinType
+    ).map((t) => POOL_ADDRESSES[t as SupportPoolCoins]?.coinType!);
+  }
   try {
-    const marketObject = address.get('core.market');
+    const marketObject = query.address.get('core.market');
     const isolatedAssets: string[] = [];
     if (!marketObject) return isolatedAssets;
 
@@ -46,7 +53,7 @@ export const getIsolatedAssets = async (
     };
 
     do {
-      const response = await address.cache.queryGetDynamicFields({
+      const response = await query.cache.queryGetDynamicFields({
         parentId: marketObject,
         cursor: nextCursor,
         limit: 10,
@@ -81,34 +88,33 @@ export const isIsolatedAsset = async (
   utils: ScallopUtils,
   coinName: SupportPoolCoins
 ): Promise<boolean> => {
-  try {
-    const marketObject = utils.address.get('core.market');
-    // check if the coin type is in the list
-    const cachedData = utils.address.cache.queryClient.getQueryData<string[]>([
-      'getDynamicFields',
-      marketObject,
-    ]);
-    if (cachedData) {
-      const coinType = utils.parseCoinType(coinName);
-      return cachedData.includes(coinType);
-    }
+  if (POOL_ADDRESSES[coinName]) {
+    return !!POOL_ADDRESSES[coinName].isolatedAssetKey;
+  }
+
+  const marketObject = utils.address.get('core.market');
+  // check if the coin type is in the list
+  const cachedData = utils.address.cache.queryClient.getQueryData<string[]>([
+    'getDynamicFields',
+    marketObject,
+  ]);
+  if (cachedData) {
+    const coinType = utils.parseCoinType(coinName);
+    return cachedData.includes(coinType);
+  }
 
-    // fetch dynamic field object
-    const coinType = utils.parseCoinType(coinName).slice(2);
+  // fetch dynamic field object
+  const coinType = utils.parseCoinType(coinName).slice(2);
 
-    const object = await utils.cache.queryGetDynamicFieldObject({
-      parentId: marketObject,
-      name: {
-        type: isolatedAssetKeyType,
-        value: coinType,
-      },
-    });
+  const object = await utils.cache.queryGetDynamicFieldObject({
+    parentId: marketObject,
+    name: {
+      type: isolatedAssetKeyType,
+      value: coinType,
+    },
+  });
 
-    const parsedData = isolatedAssetZod.safeParse(object?.data?.content);
-    if (!parsedData.success) return false;
-    return parsedData.data.fields.value;
-  } catch (e) {
-    console.error(e);
-    return false;
-  }
+  const parsedData = isolatedAssetZod.safeParse(object?.data?.content);
+  if (!parsedData.success) return false;
+  return parsedData.data.fields.value;
 };

package/src/queries/objectsQuery.ts

@@ -0,0 +1,20 @@
+import { SuiObjectDataOptions } from '@mysten/sui/dist/cjs/client';
+import { ScallopCache } from 'src/models/scallopCache';
+import { partitionArray } from 'src/utils';
+
+export const queryMultipleObjects = async (
+  cache: ScallopCache,
+  objectIds: string[],
+  options?: SuiObjectDataOptions,
+  partitionSize = 50
+) => {
+  const objectIdsPartition = partitionArray(objectIds, partitionSize);
+
+  const objects = [];
+  for (const objectIds of objectIdsPartition) {
+    const result = await cache.queryGetObjects(objectIds, options);
+    objects.push(...result);
+  }
+
+  return objects;
+};

package/src/queries/poolAddressesQuery.ts

@@ -0,0 +1,134 @@
+import { SUPPORT_POOLS } from 'src/constants';
+import { ScallopQuery } from 'src/models';
+import { OptionalKeys, SupportPoolCoins, SupportSCoin } from 'src/types';
+
+export const getAllAddresses = async (query: ScallopQuery) => {
+  const results: OptionalKeys<
+    Record<
+      SupportPoolCoins,
+      {
+        lendingPoolAddress?: string;
+        collateralPoolAddress?: string; // not all pool has collateral
+        borrowDynamic?: string;
+        spoolReward?: string;
+        spool?: string;
+        interestModel?: string;
+        riskModel?: string;
+        borrowFeeKey?: string;
+        supplyLimitKey?: string;
+        borrowLimitKey?: string;
+        isolatedAssetKey?: string;
+      }
+    >
+  > = {};
+
+  const marketId = query.address.get('core.market');
+  const marketObject = (
+    await query.cache.queryGetObject(marketId, {
+      showContent: true,
+    })
+  )?.data;
+
+  if (!(marketObject && marketObject.content?.dataType === 'moveObject'))
+    throw new Error(`Failed to fetch marketObject`);
+
+  const fields = marketObject.content.fields as any;
+
+  const coinTypesPairs = SUPPORT_POOLS.reduce(
+    (acc, pool) => {
+      acc.push([pool, query.utils.parseCoinType(pool).substring(2)]);
+      return acc;
+    },
+    [] as [SupportPoolCoins, string][]
+  );
+  const balanceSheetParentId =
+    fields.vault.fields.balance_sheets.fields.table.fields.id.id;
+
+  const collateralStatsParentId =
+    fields.collateral_stats.fields.table.fields.id.id;
+
+  const borrowDynamicsParentid =
+    fields.borrow_dynamics.fields.table.fields.id.id;
+
+  const interestModelParentId =
+    fields.interest_models.fields.table.fields.id.id;
+
+  const riskModelParentId = fields.risk_models.fields.table.fields.id.id;
+
+  const ADDRESS_TYPE = `0x1::type_name::TypeName`;
+  const BORROW_FEE_TYPE = `0xc38f849e81cfe46d4e4320f508ea7dda42934a329d5a6571bb4c3cb6ea63f5da::market_dynamic_keys::BorrowFeeKey`;
+  const SUPPLY_LIMIT_TYPE = `0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::SupplyLimitKey`;
+  const BORROW_LIMIT_TYPE = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::BorrowLimitKey`; // prod
+  const ISOLATED_ASSET_KEY = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::IsolatedAssetKey`;
+  const fetchDynamicObject = async (
+    parentId: string,
+    type: string,
+    value: any
+  ) => {
+    try {
+      return (
+        await query.cache.queryGetDynamicFieldObject({
+          parentId,
+          name: {
+            type,
+            value,
+          },
+        })
+      )?.data?.objectId;
+    } catch (_e) {
+      return undefined;
+    }
+  };
+
+  await Promise.all(
+    coinTypesPairs.map(async ([coinName, coinType]) => {
+      const addresses = await Promise.all([
+        fetchDynamicObject(balanceSheetParentId, ADDRESS_TYPE, {
+          name: coinType,
+        }),
+        fetchDynamicObject(collateralStatsParentId, ADDRESS_TYPE, {
+          name: coinType,
+        }),
+        fetchDynamicObject(borrowDynamicsParentid, ADDRESS_TYPE, {
+          name: coinType,
+        }),
+        fetchDynamicObject(interestModelParentId, ADDRESS_TYPE, {
+          name: coinType,
+        }),
+        fetchDynamicObject(riskModelParentId, ADDRESS_TYPE, {
+          name: coinType,
+        }),
+        fetchDynamicObject(marketId, BORROW_FEE_TYPE, coinType),
+        fetchDynamicObject(marketId, SUPPLY_LIMIT_TYPE, coinType),
+        fetchDynamicObject(marketId, BORROW_LIMIT_TYPE, coinType),
+        fetchDynamicObject(marketId, ISOLATED_ASSET_KEY, coinType),
+      ]);
+
+      const spool = query.address.get(
+        // @ts-ignore
+        `spool.pools.s${coinName as SupportSCoin}.id`
+      );
+      const rewardPool = query.address.get(
+        // @ts-ignore
+        `spool.pools.s${coinName}.rewardPoolId`
+      );
+      results[coinName as SupportPoolCoins] = {
+        lendingPoolAddress: addresses[0],
+        collateralPoolAddress: addresses[1],
+        borrowDynamic: addresses[2],
+        interestModel: addresses[3],
+        riskModel: addresses[4],
+        borrowFeeKey: addresses[5],
+        supplyLimitKey: addresses[6],
+        borrowLimitKey: addresses[7],
+        isolatedAssetKey: addresses[8],
+        spool,
+        spoolReward: rewardPool,
+      };
+
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    })
+  );
+
+  return results;
+};

package/src/queries/portfolioQuery.ts

@@ -51,10 +51,13 @@ export const getLendings = async (
   ) as SupportStakeMarketCoins[];
 
   const coinPrices = await query.utils.getCoinPrices();
-  const marketPools = await query.getMarketPools(poolCoinNames, {
-    indexer,
-    coinPrices,
-  });
+  const marketPools = (
+    await query.getMarketPools(poolCoinNames, {
+      indexer,
+      coinPrices,
+    })
+  ).pools;
+
   const spools = await query.getSpools(stakeMarketCoinNames, {
     indexer,
     marketPools,
@@ -309,7 +312,8 @@ export const getObligationAccounts = async (
   indexer: boolean = false
 ) => {
   const coinPrices = await query.utils.getCoinPrices();
-  const market = await query.queryMarket({ indexer, coinPrices });
+  // const market = await query.queryMarket({ indexer, coinPrices });
+  const market = await query.getMarketPools(undefined, { coinPrices, indexer });
   const [coinAmounts, obligations] = await Promise.all([
     query.getCoinAmounts(undefined, ownerAddress),
     query.getObligations(ownerAddress),
@@ -357,7 +361,8 @@ export const getObligationAccount = async (
     ...SUPPORT_COLLATERALS,
   ] as SupportCollateralCoins[];
 
-  market = market ?? (await query.queryMarket({ indexer }));
+  // market = market ?? (await query.queryMarket({ indexer }));
+  market = market ?? (await query.getMarketPools(undefined, { indexer }));
   coinPrices =
     coinPrices ?? (await query.getAllCoinPrices({ marketPools: market.pools }));
   coinAmounts =
@@ -784,7 +789,8 @@ export const getTotalValueLocked = async (
   query: ScallopQuery,
   indexer: boolean = false
 ) => {
-  const market = await query.queryMarket({ indexer });
+  // const market = await query.queryMarket({ indexer });
+  const market = await query.getMarketPools(undefined, { indexer });
 
   let supplyValue = BigNumber(0);
   let borrowValue = BigNumber(0);
@@ -811,6 +817,7 @@ export const getTotalValueLocked = async (
     );
   }
 
+  // console.dir(market.collaterals, { depth: null });
   for (const collateral of Object.values(market.collaterals)) {
     supplyValue = supplyValue.plus(
       BigNumber(collateral.depositCoin).multipliedBy(collateral.coinPrice)

package/src/queries/priceQuery.ts

@@ -142,7 +142,9 @@ export const getAllCoinPrices = async (
 ) => {
   coinPrices = coinPrices ?? (await query.utils.getCoinPrices());
   marketPools =
-    marketPools ?? (await query.getMarketPools(undefined, { coinPrices }));
+    marketPools ??
+    (await query.getMarketPools(undefined, { coinPrices })).pools;
+
   if (!marketPools) {
     throw new Error(`Failed to fetch market pool for getAllCoinPrices`);
   }

package/src/queries/spoolQuery.ts

@@ -43,7 +43,9 @@ export const getSpools = async (
   coinPrices = coinPrices ?? (await query.utils.getCoinPrices()) ?? {};
 
   marketPools =
-    marketPools ?? (await query.getMarketPools(stakeCoinNames, { indexer }));
+    marketPools ??
+    (await query.getMarketPools(stakeCoinNames, { indexer })).pools;
+
   if (!marketPools)
     throw new Error(`Fail to fetch marketPools for ${stakeCoinNames}`);
 

package/src/queries/supplyLimitQuery.ts

@@ -17,8 +17,8 @@ const supplyLimitZod = zod.object({
   }),
 });
 
-// const supplyLimitKeyType = `0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::SupplyLimitKey`; // prod
-const supplyLimitKeyType = `0x6c23585e940a989588432509107e98bae06dbca4e333f26d0635d401b3c7c76d::market_dynamic_keys::SupplyLimitKey`;
+const supplyLimitKeyType = `0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::SupplyLimitKey`; // prod
+// const supplyLimitKeyType = `0x6c23585e940a989588432509107e98bae06dbca4e333f26d0635d401b3c7c76d::market_dynamic_keys::SupplyLimitKey`;
 /**
  * Return supply limit of a pool (including the decimals)
  * @param utils

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/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,11 @@
+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 value = (object.content.fields as any).value;
+  if (typeof value === 'object' && 'fields' in value)
+    return (object.content.fields as any).value.fields as T;
+  return value as T;
+};

package/src/utils/index.ts

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

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,

package/src/utils/tokenBucket.ts

@@ -53,7 +53,7 @@ const callWithRateLimit = async <T>(
     } else if (retries < maxRetries) {
       retries++;
       const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
-      console.error(`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;
+};