@scallop-io/sui-scallop-sdk 1.4.1 → 1.4.2-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(),
@@ -27,10 +28,16 @@ const isolatedAssetKeyType = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da2
  * @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,146 @@
+import { SUPPORT_POOLS } from 'src/constants';
+import { ScallopQuery } from 'src/models';
+import { OptionalKeys, SupportPoolCoins } 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;
+        sCoinTreasury?: string;
+        interestModel?: string;
+        riskModel?: string;
+        borrowFeeKey?: string;
+        supplyLimitKey?: string;
+        borrowLimitKey?: string;
+        isolatedAssetKey?: string;
+        coinDecimalId?: string;
+        borrowIncentivePoolId?: 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}.id`
+      );
+      const rewardPool = query.address.get(
+        // @ts-ignore
+        `spool.pools.s${coinName}.rewardPoolId`
+      );
+      const sCoinTreasury = query.address.get(
+        // @ts-ignore
+        `scoin.coins.s${coinName}.treasury`
+      );
+      const coinDecimalId = query.address.get(
+        `core.coins.${coinName}.metaData`
+      );
+      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,
+        sCoinTreasury,
+        coinDecimalId,
+      };
+
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    })
+  );
+
+  return results;
+};

package/src/queries/portfolioQuery.ts

@@ -25,6 +25,7 @@ import type {
   SupportBorrowIncentiveCoins,
   ObligationBorrowIcentiveReward,
   SupportBorrowIncentiveRewardCoins,
+  SupportAssetCoins,
 } from '../types';
 
 /**
@@ -50,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,
@@ -307,8 +311,10 @@ export const getObligationAccounts = async (
   ownerAddress?: string,
   indexer: boolean = false
 ) => {
-  const coinPrices = await query.utils.getCoinPrices();
-  const market = await query.queryMarket({ indexer, coinPrices });
+  const market = await query.queryMarket({ indexer });
+  const coinPrices = await query.getAllCoinPrices({
+    marketPools: market.pools,
+  });
   const [coinAmounts, obligations] = await Promise.all([
     query.getCoinAmounts(undefined, ownerAddress),
     query.getObligations(ownerAddress),
@@ -349,15 +355,19 @@ 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,
-  ];
-  market = market ?? (await query.queryMarket({ indexer }));
+  ] as SupportCollateralCoins[];
+
+  // market = market ?? (await query.queryMarket({ indexer }));
+  market = market ?? (await query.getMarketPools(undefined, { 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 +375,7 @@ export const getObligationAccount = async (
       query.getBorrowIncentivePools(undefined, {
         coinPrices,
         indexer,
+        marketPools: market.pools,
       }),
       query.getBorrowIncentiveAccounts(obligationId),
     ]);
@@ -527,7 +538,7 @@ export const getObligationAccount = async (
         ([key, accountPoint]) => {
           const poolPoint =
             borrowIncentivePool.points[
-              key as SupportBorrowIncentiveRewardCoins
+              query.utils.parseSCoinTypeNameToMarketCoinName(key)
             ];
 
           if (accountPoint && poolPoint) {
@@ -572,6 +583,11 @@ export const getObligationAccount = async (
                   .toNumber()
               : 1;
 
+            // console.log({
+            //   availableClaimAmount: availableClaimAmount.toString(),
+            //   coinName: poolPoint.coinName,
+            //   coinType: poolPoint.coinType,
+            // });
             if (availableClaimAmount.isGreaterThanOrEqualTo(0)) {
               rewards.push({
                 coinName: poolPoint.coinName,
@@ -774,7 +790,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);
@@ -801,6 +818,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`);
   }