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

package/dist/index.mjs

@@ -1122,7 +1122,7 @@ var TEST_ADDRESSES = {
 };
 
 // src/constants/tokenBucket.ts
-var DEFAULT_TOKENS_PER_INTERVAL = 50;
+var DEFAULT_TOKENS_PER_INTERVAL = 10;
 var DEFAULT_INTERVAL_IN_MS = 250;
 
 // src/constants/vesca.ts
@@ -1792,10 +1792,16 @@ function withIndexerFallback(method) {
 var parseObjectAs = (object) => {
   if (!(object && object.content && "fields" in object.content))
     throw new Error(`Failed to parse object`);
-  const value = object.content.fields.value;
-  if (typeof value === "object" && "fields" in value)
-    return object.content.fields.value.fields;
-  return value;
+  const fields = object.content.fields;
+  if (typeof fields === "object" && "value" in fields) {
+    const value = fields.value;
+    if (typeof value === "object" && "fields" in value)
+      return value.fields;
+    return value;
+  } else if (typeof fields === "object") {
+    return fields;
+  }
+  return fields;
 };
 
 // src/models/scallopCache.ts
@@ -4560,12 +4566,80 @@ var getSCoinSwapRate = async (query, fromSCoin, toSCoin, underlyingCoinPrice) =>
 
 // src/queries/spoolQuery.ts
 import { normalizeStructTag as normalizeStructTag5 } from "@mysten/sui/utils";
+var queryRequiredSpoolObjects = async (query, stakePoolCoinNames) => {
+  const tasks = stakePoolCoinNames.map((t, idx) => ({
+    poolCoinName: stakePoolCoinNames[idx],
+    spool: POOL_ADDRESSES[t]?.spool,
+    spoolReward: POOL_ADDRESSES[t]?.spoolReward,
+    sCoinTreasury: POOL_ADDRESSES[t]?.sCoinTreasury
+  }));
+  const [spoolObjects, spoolRewardObjects, sCoinTreasuryObjects] = await Promise.all([
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.spool).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.spoolReward).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.sCoinTreasury).filter((t) => !!t)
+    )
+  ]);
+  const mapObjects = (tasks2, fetchedObjects) => {
+    const resultMap = {};
+    let fetchedIndex = 0;
+    for (const task of tasks2) {
+      const key = task[Object.keys(task)[1]];
+      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);
+  return stakePoolCoinNames.reduce(
+    (acc, name) => {
+      acc[name] = {
+        spool: spoolMap[name],
+        spoolReward: spoolRewardMap[name],
+        sCoinTreasury: sCoinTreasuryMap[name]
+      };
+      return acc;
+    },
+    {}
+  );
+};
+var parseSpoolObjects = ({
+  spool,
+  spoolReward
+}) => {
+  const _spool = parseObjectAs(spool);
+  const _spoolReward = parseObjectAs(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
+  };
+};
 var getSpools = async (query, stakeMarketCoinNames = [...SUPPORT_SPOOLS], indexer = false, marketPools, coinPrices) => {
   const stakeCoinNames = stakeMarketCoinNames.map(
     (stakeMarketCoinName) => query.utils.parseCoinName(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}`);
   const spools = {};
@@ -4580,126 +4654,93 @@ var getSpools = async (query, stakeMarketCoinNames = [...SUPPORT_SPOOLS], indexe
       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;
     };
     Object.values(spoolsIndexer).forEach(updateSpools);
     return spools;
   }
-  for (const stakeMarketCoinName of stakeMarketCoinNames) {
-    const stakeCoinName = query.utils.parseCoinName(stakeMarketCoinName);
-    const spool = await getSpool(
-      query,
-      stakeMarketCoinName,
-      indexer,
-      marketPools[stakeCoinName],
-      coinPrices
-    );
-    if (spool) {
-      spools[stakeMarketCoinName] = spool;
-    }
-  }
+  const requiredObjects = await queryRequiredSpoolObjects(
+    query,
+    stakeCoinNames
+  );
+  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;
 };
-var getSpool = async (query, marketCoinName, indexer = false, marketPool, coinPrices) => {
+var getSpool = async (query, marketCoinName, indexer = false, coinPrices, requiredObjects) => {
   const coinName = query.utils.parseCoinName(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 = void 0;
-  coinPrices = coinPrices || await query.utils.getCoinPrices();
+  coinPrices = coinPrices || await query.getAllCoinPrices();
   if (indexer) {
     const spoolIndexer = await query.indexer.getSpool(marketCoinName);
     const coinName2 = query.utils.parseCoinName(marketCoinName);
     const rewardCoinName2 = query.utils.getSpoolRewardCoinName(marketCoinName);
-    spoolIndexer.coinPrice = coinPrices?.[coinName2] || spoolIndexer.coinPrice;
-    spoolIndexer.marketCoinPrice = (coinPrices?.[coinName2] ?? 0) * (marketPool ? marketPool.conversionRate : 0) || spoolIndexer.marketCoinPrice;
-    spoolIndexer.rewardCoinPrice = coinPrices?.[rewardCoinName2] || spoolIndexer.rewardCoinPrice;
+    spoolIndexer.coinPrice = coinPrices?.[coinName2] ?? spoolIndexer.coinPrice;
+    spoolIndexer.marketCoinPrice = coinPrices?.[marketCoinName] ?? spoolIndexer.marketCoinPrice;
+    spoolIndexer.rewardCoinPrice = coinPrices?.[rewardCoinName2] ?? 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 ?? (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;
-    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
-    );
-    if (rewardPoolObject.content && "fields" in rewardPoolObject.content) {
-      const rewardPoolFields = rewardPoolObject.content.fields;
-      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 rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
-      const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
-      const calculatedRewardPoolData = calculateSpoolRewardPoolData(
-        parsedSpoolData,
-        parsedSpoolRewardPoolData,
-        calculatedSpoolData,
-        rewardCoinPrice,
-        rewardCoinDecimal
-      );
-      spool = {
-        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,
-        rewardCoinPrice,
-        maxPoint: parsedSpoolData.maxPoint,
-        distributedPoint: parsedSpoolData.distributedPoint,
-        maxStake: parsedSpoolData.maxStake,
-        ...calculatedSpoolData,
-        exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
-        exchangeRateDenominator: parsedSpoolRewardPoolData.exchangeRateDenominator,
-        ...calculatedRewardPoolData
-      };
-    }
-  }
-  return spool;
+  const parsedSpoolObjects = parseSpoolObjects(requiredObjects);
+  const parsedSpoolData = parseOriginSpoolData(parsedSpoolObjects);
+  const marketCoinPrice = coinPrices?.[marketCoinName] ?? 0;
+  const marketCoinDecimal = query.utils.getCoinDecimal(marketCoinName);
+  const calculatedSpoolData = calculateSpoolData(
+    parsedSpoolData,
+    marketCoinPrice,
+    marketCoinDecimal
+  );
+  const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData(parsedSpoolObjects);
+  const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+  const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+  const calculatedRewardPoolData = calculateSpoolRewardPoolData(
+    parsedSpoolData,
+    parsedSpoolRewardPoolData,
+    calculatedSpoolData,
+    rewardCoinPrice,
+    rewardCoinDecimal
+  );
+  return {
+    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,
+    rewardCoinPrice,
+    maxPoint: parsedSpoolData.maxPoint,
+    distributedPoint: parsedSpoolData.distributedPoint,
+    maxStake: parsedSpoolData.maxStake,
+    ...calculatedSpoolData,
+    exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
+    exchangeRateDenominator: parsedSpoolRewardPoolData.exchangeRateDenominator,
+    ...calculatedRewardPoolData
+  };
 };
 var getStakeAccounts = async ({
   utils
@@ -5120,6 +5161,10 @@ var getAllAddresses = async (query) => {
         // @ts-ignore
         `spool.pools.s${coinName}.rewardPoolId`
       );
+      const sCoinTreasury = query.address.get(
+        // @ts-ignore
+        `scoin.coins.s${coinName}.treasury`
+      );
       results[coinName] = {
         lendingPoolAddress: addresses[0],
         collateralPoolAddress: addresses[1],
@@ -5131,7 +5176,8 @@ var getAllAddresses = async (query) => {
         borrowLimitKey: addresses[7],
         isolatedAssetKey: addresses[8],
         spool,
-        spoolReward: rewardPool
+        spoolReward: rewardPool,
+        sCoinTreasury
       };
       await new Promise((resolve) => setTimeout(resolve, 200));
     })
@@ -7652,13 +7698,8 @@ var ScallopQuery = class {
    * @return Spool data.
    */
   async getSpool(stakeMarketCoinName, args) {
-    return await getSpool(
-      this,
-      stakeMarketCoinName,
-      args?.indexer,
-      args?.marketPool,
-      args?.coinPrices
-    );
+    const spools = await this.getSpools(void 0, args);
+    return spools[stakeMarketCoinName];
   }
   /**
    * Get stake accounts data for all stake pools (spools).
@@ -8987,9 +9028,11 @@ export {
   ScallopQuery,
   ScallopUtils,
   TEST_ADDRESSES,
+  TokenBucket,
   UNLOCK_ROUND_DURATION,
   USE_TEST_ADDRESS,
   assetCoins,
+  callWithRateLimit,
   coinDecimals,
   coinIds,
   marketCoins,