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

package/src/queries/coreQuery.ts

@@ -13,7 +13,11 @@ import {
   calculateMarketCollateralData,
   parseObjectAs,
 } from '../utils';
-import type { SuiObjectResponse, SuiObjectData } from '@mysten/sui/client';
+import type {
+  SuiObjectResponse,
+  SuiObjectData,
+  SuiParsedData,
+} from '@mysten/sui/client';
 import type { SuiObjectArg } from '@scallop-io/sui-kit';
 import type { ScallopAddress, ScallopCache, ScallopQuery } from '../models';
 import {
@@ -902,14 +906,32 @@ export const getObligations = async (
   const keyObjects = keyObjectsResponse.filter((ref) => !!ref.data);
 
   const obligations: Obligation[] = [];
+  // fetch all obligations with multi get objects
+  const obligationsObjects = await queryMultipleObjects(
+    address.cache,
+    keyObjects
+      .map((ref) => ref.data?.content)
+      .filter(
+        (content): content is SuiParsedData & { dataType: 'moveObject' } =>
+          content?.dataType === 'moveObject'
+      )
+      .map((content) => (content.fields as any).ownership.fields.of),
+    {
+      showContent: true,
+    }
+  );
+
   await Promise.allSettled(
-    keyObjects.map(async ({ data }) => {
+    keyObjects.map(async ({ data }, idx) => {
       const keyId = data?.objectId;
       const content = data?.content;
       if (keyId && content && 'fields' in content) {
         const fields = content.fields as any;
         const obligationId = String(fields.ownership.fields.of);
-        const locked = await getObligationLocked(address.cache, obligationId);
+        const locked = await getObligationLocked(
+          address.cache,
+          obligationsObjects[idx]
+        );
         obligations.push({ id: obligationId, keyId, locked });
       }
     })
@@ -929,7 +951,7 @@ export const getObligationLocked = async (
   cache: ScallopCache,
   obligation: string | SuiObjectData
 ) => {
-  const obligationObjectResponse =
+  const obligationObjectData =
     typeof obligation === 'string'
       ? (
           await cache.queryGetObject(obligation, {
@@ -939,13 +961,11 @@ export const getObligationLocked = async (
       : obligation;
   let obligationLocked = false;
   if (
-    obligationObjectResponse &&
-    obligationObjectResponse?.content?.dataType === 'moveObject' &&
-    'lock_key' in obligationObjectResponse.content.fields
+    obligationObjectData &&
+    obligationObjectData?.content?.dataType === 'moveObject' &&
+    'lock_key' in obligationObjectData.content.fields
   ) {
-    obligationLocked = Boolean(
-      obligationObjectResponse.content.fields.lock_key
-    );
+    obligationLocked = Boolean(obligationObjectData.content.fields.lock_key);
   }
 
   return obligationLocked;

package/src/queries/poolAddressesQuery.ts

@@ -1,6 +1,6 @@
 import { SUPPORT_POOLS } from 'src/constants';
 import { ScallopQuery } from 'src/models';
-import { OptionalKeys, SupportPoolCoins, SupportSCoin } from 'src/types';
+import { OptionalKeys, SupportPoolCoins } from 'src/types';
 
 export const getAllAddresses = async (query: ScallopQuery) => {
   const results: OptionalKeys<
@@ -12,12 +12,15 @@ export const getAllAddresses = async (query: ScallopQuery) => {
         borrowDynamic?: string;
         spoolReward?: string;
         spool?: string;
+        sCoinTreasury?: string;
         interestModel?: string;
         riskModel?: string;
         borrowFeeKey?: string;
         supplyLimitKey?: string;
         borrowLimitKey?: string;
         isolatedAssetKey?: string;
+        coinDecimalId?: string;
+        borrowIncentivePoolId?: string;
       }
     >
   > = {};
@@ -106,12 +109,19 @@ export const getAllAddresses = async (query: ScallopQuery) => {
 
       const spool = query.address.get(
         // @ts-ignore
-        `spool.pools.s${coinName as SupportSCoin}.id`
+        `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],
@@ -124,6 +134,8 @@ export const getAllAddresses = async (query: ScallopQuery) => {
         isolatedAssetKey: addresses[8],
         spool,
         spoolReward: rewardPool,
+        sCoinTreasury,
+        coinDecimalId,
       };
 
       await new Promise((resolve) => setTimeout(resolve, 200));

package/src/queries/portfolioQuery.ts

@@ -366,7 +366,7 @@ export const getObligationAccount = async (
   coinPrices =
     coinPrices ?? (await query.getAllCoinPrices({ marketPools: market.pools }));
   coinAmounts =
-    coinAmounts || (await query.getCoinAmounts(coinNames, ownerAddress));
+    coinAmounts ?? (await query.getCoinAmounts(coinNames, ownerAddress));
 
   const [obligationQuery, borrowIncentivePools, borrowIncentiveAccounts] =
     await Promise.all([

package/src/queries/spoolQuery.ts

@@ -1,16 +1,16 @@
 import { normalizeStructTag } from '@mysten/sui/utils';
-import { SUPPORT_SPOOLS } from '../constants';
+import { POOL_ADDRESSES, SUPPORT_SPOOLS } from '../constants';
 import {
   parseOriginSpoolData,
   calculateSpoolData,
   parseOriginSpoolRewardPoolData,
   calculateSpoolRewardPoolData,
   isMarketCoin,
+  parseObjectAs,
 } from '../utils';
-import type { SuiObjectResponse } from '@mysten/sui/client';
+import type { SuiObjectData, SuiObjectResponse } from '@mysten/sui/client';
 import type { ScallopQuery, ScallopUtils } from '../models';
 import type {
-  MarketPool,
   Spools,
   Spool,
   StakePool,
@@ -20,7 +20,107 @@ import type {
   SupportStakeCoins,
   CoinPrices,
   MarketPools,
+  OriginSpoolRewardPoolData,
+  SpoolData,
+  OriginSpoolData,
 } from '../types';
+import { queryMultipleObjects } from './objectsQuery';
+
+const queryRequiredSpoolObjects = async (
+  query: ScallopQuery,
+  stakePoolCoinNames: SupportStakeCoins[]
+) => {
+  // Prepare all tasks for querying each object type
+  const tasks = stakePoolCoinNames.map((t, idx) => ({
+    poolCoinName: stakePoolCoinNames[idx],
+    spool: POOL_ADDRESSES[t]?.spool,
+    spoolReward: POOL_ADDRESSES[t]?.spoolReward,
+    sCoinTreasury: POOL_ADDRESSES[t]?.sCoinTreasury,
+  }));
+
+  // Query all objects for each key in parallel
+  const [spoolObjects, spoolRewardObjects, sCoinTreasuryObjects] =
+    await Promise.all([
+      queryMultipleObjects(
+        query.cache,
+        tasks.map((task) => task.spool).filter((t): t is string => !!t)
+      ),
+      queryMultipleObjects(
+        query.cache,
+        tasks.map((task) => task.spoolReward).filter((t): t is string => !!t)
+      ),
+      queryMultipleObjects(
+        query.cache,
+        tasks.map((task) => task.sCoinTreasury).filter((t): t is string => !!t)
+      ),
+    ]);
+
+  // Map the results back to poolCoinNames
+  const mapObjects = (
+    tasks: { poolCoinName: string; [key: string]: string | undefined }[],
+    fetchedObjects: SuiObjectData[]
+  ) => {
+    const resultMap: Record<string, SuiObjectData> = {};
+    let fetchedIndex = 0;
+
+    for (const task of tasks) {
+      const key = task[Object.keys(task)[1]]; // current object key being queried
+      if (key) {
+        resultMap[task.poolCoinName] = fetchedObjects[fetchedIndex];
+        fetchedIndex++;
+      }
+    }
+    return resultMap;
+  };
+
+  const spoolMap = mapObjects(tasks, spoolObjects);
+  const spoolRewardMap = mapObjects(tasks, spoolRewardObjects);
+  const sCoinTreasuryMap = mapObjects(tasks, sCoinTreasuryObjects);
+
+  // Construct the final requiredObjects result
+  return stakePoolCoinNames.reduce(
+    (acc, name) => {
+      acc[name] = {
+        spool: spoolMap[name],
+        spoolReward: spoolRewardMap[name],
+        sCoinTreasury: sCoinTreasuryMap[name],
+      };
+      return acc;
+    },
+    {} as Record<
+      SupportStakeCoins,
+      {
+        spool: SuiObjectData;
+        spoolReward: SuiObjectData;
+        sCoinTreasury: SuiObjectData;
+      }
+    >
+  );
+};
+
+const parseSpoolObjects = ({
+  spool,
+  spoolReward,
+}: {
+  spool: SuiObjectData;
+  spoolReward: SuiObjectData;
+}): OriginSpoolData & OriginSpoolRewardPoolData => {
+  const _spool = parseObjectAs<SpoolData>(spool);
+  const _spoolReward = parseObjectAs<OriginSpoolRewardPoolData>(spoolReward);
+  return {
+    stakeType: _spool.stake_type,
+    maxDistributedPoint: _spool.max_distributed_point,
+    distributedPoint: _spool.distributed_point,
+    distributedPointPerPeriod: _spool.distributed_point_per_period,
+    pointDistributionTime: _spool.point_distribution_time,
+    maxStake: _spool.max_stakes,
+    stakes: _spool.stakes,
+    index: _spool.index,
+    createdAt: _spool.created_at,
+    lastUpdate: _spool.last_update,
+    ..._spoolReward,
+  };
+};
 
 /**
  * Get spools data.
@@ -40,12 +140,13 @@ export const getSpools = async (
   const stakeCoinNames = stakeMarketCoinNames.map((stakeMarketCoinName) =>
     query.utils.parseCoinName<SupportStakeCoins>(stakeMarketCoinName)
   );
-  coinPrices = coinPrices ?? (await query.utils.getCoinPrices()) ?? {};
-
   marketPools =
     marketPools ??
     (await query.getMarketPools(stakeCoinNames, { indexer })).pools;
 
+  coinPrices =
+    coinPrices ?? (await query.getAllCoinPrices({ marketPools })) ?? {};
+
   if (!marketPools)
     throw new Error(`Fail to fetch marketPools for ${stakeCoinNames}`);
 
@@ -61,12 +162,9 @@ export const getSpools = async (
       const rewardCoinName = query.utils.getSpoolRewardCoinName(
         spool.marketCoinName
       );
-      const marketPool = marketPools[coinName];
       spool.coinPrice = coinPrices[coinName] ?? spool.coinPrice;
-      spool.marketCoinPrice = coinPrices[coinName]
-        ? (coinPrices[coinName] ?? 0) *
-          (marketPool ? marketPool.conversionRate : 0)
-        : spool.marketCoinPrice;
+      spool.marketCoinPrice =
+        coinPrices[spool.marketCoinName] ?? spool.marketCoinPrice;
       spool.rewardCoinPrice =
         coinPrices[rewardCoinName] ?? spool.rewardCoinPrice;
       spools[spool.marketCoinName] = spool;
@@ -76,21 +174,31 @@ export const getSpools = async (
     return spools;
   }
 
-  for (const stakeMarketCoinName of stakeMarketCoinNames) {
-    const stakeCoinName =
-      query.utils.parseCoinName<SupportStakeCoins>(stakeMarketCoinName);
-    const spool = await getSpool(
-      query,
-      stakeMarketCoinName,
-      indexer,
-      marketPools[stakeCoinName],
-      coinPrices
-    );
+  const requiredObjects = await queryRequiredSpoolObjects(
+    query,
+    stakeCoinNames
+  );
 
-    if (spool) {
-      spools[stakeMarketCoinName] = spool;
-    }
-  }
+  await Promise.allSettled(
+    stakeMarketCoinNames.map(async (stakeMarketCoinName, idx) => {
+      try {
+        const stakeCoinName = stakeCoinNames[idx];
+        const spool = await getSpool(
+          query,
+          stakeMarketCoinName,
+          indexer,
+          coinPrices,
+          requiredObjects[stakeCoinName]
+        );
+
+        if (spool) {
+          spools[stakeMarketCoinName] = spool;
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    })
+  );
 
   return spools;
 };
@@ -109,126 +217,83 @@ export const getSpool = async (
   query: ScallopQuery,
   marketCoinName: SupportStakeMarketCoins,
   indexer: boolean = false,
-  marketPool?: MarketPool,
-  coinPrices?: CoinPrices
+  coinPrices?: CoinPrices,
+  requiredObjects?: {
+    spool: SuiObjectData;
+    spoolReward: SuiObjectData;
+  }
 ) => {
   const coinName = query.utils.parseCoinName<SupportStakeCoins>(marketCoinName);
-  marketPool = marketPool || (await query.getMarketPool(coinName, { indexer }));
-  if (!marketPool) {
-    throw new Error(`Failed to fetch marketPool for ${marketCoinName}`);
-  }
-
-  const poolId = query.address.get(`spool.pools.${marketCoinName}.id`);
-  const rewardPoolId = query.address.get(
-    `spool.pools.${marketCoinName}.rewardPoolId`
-  );
-  let spool: Spool | undefined = undefined;
-  coinPrices = coinPrices || (await query.utils.getCoinPrices());
+  coinPrices = coinPrices || (await query.getAllCoinPrices());
 
   if (indexer) {
     const spoolIndexer = await query.indexer.getSpool(marketCoinName);
     const coinName =
       query.utils.parseCoinName<SupportStakeCoins>(marketCoinName);
     const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
-    spoolIndexer.coinPrice = coinPrices?.[coinName] || spoolIndexer.coinPrice;
+    spoolIndexer.coinPrice = coinPrices?.[coinName] ?? spoolIndexer.coinPrice;
     spoolIndexer.marketCoinPrice =
-      (coinPrices?.[coinName] ?? 0) *
-        (marketPool ? marketPool.conversionRate : 0) ||
-      spoolIndexer.marketCoinPrice;
+      coinPrices?.[marketCoinName] ?? spoolIndexer.marketCoinPrice;
     spoolIndexer.rewardCoinPrice =
-      coinPrices?.[rewardCoinName] || spoolIndexer.rewardCoinPrice;
+      coinPrices?.[rewardCoinName] ?? spoolIndexer.rewardCoinPrice;
 
     return spoolIndexer;
   }
 
-  const spoolObjectResponse = await query.cache.queryGetObjects(
-    [poolId, rewardPoolId],
-    {
-      showContent: true,
-    }
-  );
-
-  if (!(spoolObjectResponse[0] && spoolObjectResponse[1])) {
-    throw new Error('Fail to fetch spoolObjectResponse!');
-  }
+  requiredObjects ??= (await queryRequiredSpoolObjects(query, [coinName]))[
+    coinName
+  ];
 
   const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
   coinPrices = coinPrices || (await query.utils.getCoinPrices());
 
-  const spoolObject = spoolObjectResponse[0];
-  const rewardPoolObject = spoolObjectResponse[1];
-  if (spoolObject.content && 'fields' in spoolObject.content) {
-    const spoolFields = spoolObject.content.fields as any;
-    const parsedSpoolData = parseOriginSpoolData({
-      stakeType: spoolFields.stake_type,
-      maxDistributedPoint: spoolFields.max_distributed_point,
-      distributedPoint: spoolFields.distributed_point,
-      distributedPointPerPeriod: spoolFields.distributed_point_per_period,
-      pointDistributionTime: spoolFields.point_distribution_time,
-      maxStake: spoolFields.max_stakes,
-      stakes: spoolFields.stakes,
-      index: spoolFields.index,
-      createdAt: spoolFields.created_at,
-      lastUpdate: spoolFields.last_update,
-    });
-
-    const marketCoinPrice =
-      (coinPrices?.[coinName] ?? 0) * marketPool.conversionRate;
-    const marketCoinDecimal = query.utils.getCoinDecimal(marketCoinName);
-    const calculatedSpoolData = calculateSpoolData(
-      parsedSpoolData,
-      marketCoinPrice,
-      marketCoinDecimal
-    );
+  const parsedSpoolObjects = parseSpoolObjects(requiredObjects);
+  const parsedSpoolData = parseOriginSpoolData(parsedSpoolObjects);
 
-    if (rewardPoolObject.content && 'fields' in rewardPoolObject.content) {
-      const rewardPoolFields = rewardPoolObject.content.fields as any;
-      const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData({
-        claimed_rewards: rewardPoolFields.claimed_rewards,
-        exchange_rate_numerator: rewardPoolFields.exchange_rate_numerator,
-        exchange_rate_denominator: rewardPoolFields.exchange_rate_denominator,
-        rewards: rewardPoolFields.rewards,
-        spool_id: rewardPoolFields.spool_id,
-      });
+  const marketCoinPrice = coinPrices?.[marketCoinName] ?? 0;
+  const marketCoinDecimal = query.utils.getCoinDecimal(marketCoinName);
+  const calculatedSpoolData = calculateSpoolData(
+    parsedSpoolData,
+    marketCoinPrice,
+    marketCoinDecimal
+  );
 
-      const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
-      const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+  const parsedSpoolRewardPoolData =
+    parseOriginSpoolRewardPoolData(parsedSpoolObjects);
 
-      const calculatedRewardPoolData = calculateSpoolRewardPoolData(
-        parsedSpoolData,
-        parsedSpoolRewardPoolData,
-        calculatedSpoolData,
-        rewardCoinPrice,
-        rewardCoinDecimal
-      );
+  const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+  const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
 
-      spool = {
-        marketCoinName: marketCoinName,
-        symbol: query.utils.parseSymbol(marketCoinName),
-        coinType: query.utils.parseCoinType(coinName),
-        marketCoinType: query.utils.parseMarketCoinType(coinName),
-        rewardCoinType: isMarketCoin(rewardCoinName)
-          ? query.utils.parseMarketCoinType(rewardCoinName)
-          : query.utils.parseCoinType(rewardCoinName),
-        sCoinType: marketPool.sCoinType,
-        coinDecimal: query.utils.getCoinDecimal(coinName),
-        rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoinName),
-        coinPrice: coinPrices?.[coinName] ?? 0,
-        marketCoinPrice: marketCoinPrice,
-        rewardCoinPrice: rewardCoinPrice,
-        maxPoint: parsedSpoolData.maxPoint,
-        distributedPoint: parsedSpoolData.distributedPoint,
-        maxStake: parsedSpoolData.maxStake,
-        ...calculatedSpoolData,
-        exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
-        exchangeRateDenominator:
-          parsedSpoolRewardPoolData.exchangeRateDenominator,
-        ...calculatedRewardPoolData,
-      };
-    }
-  }
+  const calculatedRewardPoolData = calculateSpoolRewardPoolData(
+    parsedSpoolData,
+    parsedSpoolRewardPoolData,
+    calculatedSpoolData,
+    rewardCoinPrice,
+    rewardCoinDecimal
+  );
 
-  return spool;
+  return {
+    marketCoinName: marketCoinName,
+    symbol: query.utils.parseSymbol(marketCoinName),
+    coinType: query.utils.parseCoinType(coinName),
+    marketCoinType: query.utils.parseMarketCoinType(coinName),
+    rewardCoinType: isMarketCoin(rewardCoinName)
+      ? query.utils.parseMarketCoinType(rewardCoinName)
+      : query.utils.parseCoinType(rewardCoinName),
+    sCoinType: query.utils.parseSCoinType(marketCoinName),
+    coinDecimal: query.utils.getCoinDecimal(coinName),
+    rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoinName),
+    coinPrice: coinPrices?.[coinName] ?? 0,
+    marketCoinPrice: marketCoinPrice,
+    rewardCoinPrice: rewardCoinPrice,
+    maxPoint: parsedSpoolData.maxPoint,
+    distributedPoint: parsedSpoolData.distributedPoint,
+    maxStake: parsedSpoolData.maxStake,
+    ...calculatedSpoolData,
+    exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
+    exchangeRateDenominator: parsedSpoolRewardPoolData.exchangeRateDenominator,
+    ...calculatedRewardPoolData,
+  };
 };
 
 /**

package/src/test.ts

@@ -0,0 +1,17 @@
+import { ScallopQuery } from './models';
+
+const main = async () => {
+  try {
+    const query = new ScallopQuery({});
+    await query.init();
+
+    const res = await query.getSpool('ssui');
+    console.dir(res, { depth: null });
+  } catch (e) {
+    console.error(e);
+  } finally {
+    process.exit(0);
+  }
+};
+
+main();

package/src/types/builder/core.ts

@@ -1,6 +1,7 @@
 import type {
   SuiTxBlock as SuiKitTxBlock,
   SuiObjectArg,
+  SuiTxArg,
 } from '@scallop-io/sui-kit';
 import type { Argument, TransactionResult } from '@mysten/sui/transactions';
 import type { ScallopBuilder } from '../../models';
@@ -65,7 +66,7 @@ export type CoreNormalMethods = {
     obligation: SuiObjectArg,
     obligationKey: SuiObjectArg,
     borrowReferral: SuiObjectArg,
-    amount: number,
+    amount: number | SuiTxArg,
     poolCoinName: SupportPoolCoins
   ) => TransactionResult;
   borrowEntry: (
@@ -80,7 +81,7 @@ export type CoreNormalMethods = {
     poolCoinName: SupportPoolCoins
   ) => void;
   borrowFlashLoan: (
-    amount: number,
+    amount: number | SuiTxArg,
     poolCoinName: SupportPoolCoins
   ) => TransactionResult;
   repayFlashLoan: (

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/utils/core.ts

@@ -4,8 +4,15 @@ 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;
+  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

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