@scallop-io/sui-scallop-sdk 0.47.0-alpha.3 → 0.47.0-alpha.5

package/dist/queries/borrowIncentiveQuery.d.ts

@@ -1,5 +1,5 @@
 import type { ScallopAddress, ScallopQuery, ScallopUtils } from '../models';
-import type { SupportBorrowIncentiveCoins } from '../types';
+import type { SupportBorrowIncentiveCoins, BorrowIncentivePool } from '../types';
 /**
  * Query borrow incentive pools data.
  *
@@ -9,14 +9,14 @@ import type { SupportBorrowIncentiveCoins } from '../types';
  * @return Borrow incentive pools data.
  */
 export declare const queryBorrowIncentivePools: (query: ScallopQuery, borrowIncentiveCoinNames?: SupportBorrowIncentiveCoins[], indexer?: boolean) => Promise<{
-    weth?: import("../types").BorrowIncentivePool | undefined;
-    wusdc?: import("../types").BorrowIncentivePool | undefined;
-    wusdt?: import("../types").BorrowIncentivePool | undefined;
-    sui?: import("../types").BorrowIncentivePool | undefined;
-    afsui?: import("../types").BorrowIncentivePool | undefined;
-    hasui?: import("../types").BorrowIncentivePool | undefined;
-    vsui?: import("../types").BorrowIncentivePool | undefined;
-    sca?: import("../types").BorrowIncentivePool | undefined;
+    weth?: BorrowIncentivePool | undefined;
+    wusdc?: BorrowIncentivePool | undefined;
+    wusdt?: BorrowIncentivePool | undefined;
+    sui?: BorrowIncentivePool | undefined;
+    afsui?: BorrowIncentivePool | undefined;
+    hasui?: BorrowIncentivePool | undefined;
+    vsui?: BorrowIncentivePool | undefined;
+    sca?: BorrowIncentivePool | undefined;
 }>;
 /**
  * Query borrow incentive accounts data.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "0.47.0-alpha.3",
+  "version": "0.47.0-alpha.5",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",
@@ -38,8 +38,9 @@
     "src"
   ],
   "dependencies": {
+    "@graphql-typed-document-node/core": "^3.2.0",
     "@mysten/bcs": "^0.8.1",
-    "@mysten/sui.js": "^0.52.0",
+    "@mysten/sui.js": "^0.54.1",
     "@noble/curves": "^1.2.0",
     "@noble/hashes": "^1.3.2",
     "@pythnetwork/price-service-client": "^1.8.2",
@@ -50,6 +51,8 @@
     "axios": "^1.6.0",
     "bech32": "^2.0.0",
     "bignumber.js": "^9.1.2",
+    "gql.tada": "^1.8.10",
+    "graphql": "^16.9.0",
     "superstruct": "^1.0.3",
     "tweetnacl": "^1.0.3",
     "zod": "^3.23.8"
@@ -76,7 +79,7 @@
     "vitest": "^0.34.6"
   },
   "peerDependencies": {
-    "@mysten/sui.js": "0.52.0",
+    "@mysten/sui.js": "0.54.1",
     "@scallop-io/sui-kit": "0.52.0",
     "bn.js": "^5.2.1"
   },

package/src/builders/coreBuilder.ts

@@ -392,7 +392,7 @@ const generateCoreQuickMethod: GenerateCoreQuickMethod = ({
         (await builder.utils.getObligationCoinNames(
           obligationInfo.obligationId
         )) ?? [];
-      const updateCoinNames = [...(obligationCoinNames ?? []), poolCoinName];
+      const updateCoinNames = [...obligationCoinNames, poolCoinName];
       await updateOracles(builder, txBlock, updateCoinNames);
       return txBlock.borrow(
         obligationInfo.obligationId,

package/src/queries/borrowIncentiveQuery.ts

@@ -18,6 +18,7 @@ import type {
   SupportBorrowIncentiveRewardCoins,
   BorrowIncentivePoolPoints,
   OptionalKeys,
+  BorrowIncentivePool,
 } from '../types';
 import BigNumber from 'bignumber.js';
 
@@ -31,39 +32,35 @@ import BigNumber from 'bignumber.js';
  */
 export const queryBorrowIncentivePools = async (
   query: ScallopQuery,
-  borrowIncentiveCoinNames?: SupportBorrowIncentiveCoins[],
+  borrowIncentiveCoinNames: SupportBorrowIncentiveCoins[] = [
+    ...SUPPORT_BORROW_INCENTIVE_POOLS,
+  ],
   indexer: boolean = false
 ) => {
-  borrowIncentiveCoinNames = borrowIncentiveCoinNames || [
-    ...SUPPORT_BORROW_INCENTIVE_POOLS,
-  ];
-
   const borrowIncentivePools: BorrowIncentivePools = {};
 
-  const coinPrices = await query.utils.getCoinPrices(
-    [
+  const coinPrices =
+    (await query.utils.getCoinPrices([
       ...new Set([
         ...borrowIncentiveCoinNames,
         ...SUPPORT_BORROW_INCENTIVE_REWARDS,
       ]),
-    ] ?? []
-  );
+    ])) ?? {};
 
   if (indexer) {
     const borrowIncentivePoolsIndexer =
       await query.indexer.getBorrowIncentivePools();
-    for (const borrowIncentivePool of Object.values(
-      borrowIncentivePoolsIndexer
-    )) {
-      if (!borrowIncentiveCoinNames.includes(borrowIncentivePool.coinName))
-        continue;
-      borrowIncentivePool.coinPrice =
-        coinPrices[borrowIncentivePool.coinName] ||
-        borrowIncentivePool.coinPrice;
-      // borrowIncentivePool.rewardCoinPrice =
-      //   coinPrices[rewardCoinName] || borrowIncentivePool.rewardCoinPrice;
-      borrowIncentivePools[borrowIncentivePool.coinName] = borrowIncentivePool;
-    }
+
+    const updateBorrowIncentivePool = (pool: BorrowIncentivePool) => {
+      if (!borrowIncentiveCoinNames.includes(pool.coinName)) return;
+      pool.coinPrice = coinPrices[pool.coinName] || pool.coinPrice;
+      borrowIncentivePools[pool.coinName] = pool;
+    };
+
+    Object.values(borrowIncentivePoolsIndexer).forEach(
+      updateBorrowIncentivePool
+    );
+
     return borrowIncentivePools;
   }
 

package/src/queries/coreQuery.ts

@@ -60,20 +60,25 @@ export const queryMarket = async (
 
   if (indexer) {
     const marketIndexer = await query.indexer.getMarket();
-    for (const pool of Object.values(marketIndexer.pools)) {
-      pool.coinPrice = coinPrices[pool.coinName] || pool.coinPrice;
-      pool.coinWrappedType = query.utils.getCoinWrappedType(pool.coinName);
-    }
-    for (const collateral of Object.values(marketIndexer.collaterals)) {
-      collateral.coinPrice =
-        coinPrices[collateral.coinName] || collateral.coinPrice;
-      collateral.coinWrappedType = query.utils.getCoinWrappedType(
-        collateral.coinName
-      );
-    }
+
+    const updatePools = (item: MarketPool) => {
+      item.coinPrice = coinPrices[item.coinName] || item.coinPrice;
+      item.coinWrappedType = query.utils.getCoinWrappedType(item.coinName);
+      pools[item.coinName] = item;
+    };
+
+    const updateCollaterals = (item: MarketCollateral) => {
+      item.coinPrice = coinPrices[item.coinName] || item.coinPrice;
+      item.coinWrappedType = query.utils.getCoinWrappedType(item.coinName);
+      collaterals[item.coinName] = item;
+    };
+
+    Object.values(marketIndexer.pools).forEach(updatePools);
+    Object.values(marketIndexer.collaterals).forEach(updateCollaterals);
+
     return {
-      pools: marketIndexer.pools,
-      collaterals: marketIndexer.collaterals,
+      pools,
+      collaterals,
     };
   }
 
@@ -221,29 +226,31 @@ export const queryMarket = async (
  */
 export const getMarketPools = async (
   query: ScallopQuery,
-  poolCoinNames?: SupportPoolCoins[],
+  poolCoinNames: SupportPoolCoins[] = [...SUPPORT_POOLS],
   indexer: boolean = false
 ) => {
-  poolCoinNames = poolCoinNames || [...SUPPORT_POOLS];
   const marketId = query.address.get('core.market');
   const marketObjectResponse = await query.cache.queryGetObject(marketId, {
     showContent: true,
   });
-  const coinPrices = await query.utils.getCoinPrices(poolCoinNames ?? []);
+  const coinPrices = (await query.utils.getCoinPrices(poolCoinNames)) ?? {};
 
   const marketPools: MarketPools = {};
 
   if (indexer) {
     const marketPoolsIndexer = await query.indexer.getMarketPools();
-    for (const marketPool of Object.values(marketPoolsIndexer)) {
-      if (!poolCoinNames.includes(marketPool.coinName)) continue;
+
+    const updateMarketPool = (marketPool: MarketPool) => {
+      if (!poolCoinNames.includes(marketPool.coinName)) return;
       marketPool.coinPrice =
         coinPrices[marketPool.coinName] || marketPool.coinPrice;
       marketPool.coinWrappedType = query.utils.getCoinWrappedType(
         marketPool.coinName
       );
       marketPools[marketPool.coinName] = marketPool;
-    }
+    };
+
+    Object.values(marketPoolsIndexer).forEach(updateMarketPool);
 
     return marketPools;
   }
@@ -290,6 +297,10 @@ export const getMarketPool = async (
   let interestModel: InterestModel | undefined;
   let borrowFeeRate: { value: string } | undefined;
 
+  coinPrice =
+    coinPrice ||
+    (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
+
   if (indexer) {
     const marketPoolIndexer = await query.indexer.getMarketPool(poolCoinName);
     marketPoolIndexer.coinPrice = coinPrice || marketPoolIndexer.coinPrice;
@@ -309,10 +320,6 @@ export const getMarketPool = async (
       })
     )?.data;
 
-  coinPrice =
-    coinPrice ||
-    (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
-
   if (marketObject) {
     if (marketObject.content && 'fields' in marketObject.content) {
       const fields = marketObject.content.fields as any;
@@ -507,33 +514,32 @@ export const getMarketPool = async (
  */
 export const getMarketCollaterals = async (
   query: ScallopQuery,
-  collateralCoinNames?: SupportCollateralCoins[],
+  collateralCoinNames: SupportCollateralCoins[] = [...SUPPORT_COLLATERALS],
   indexer: boolean = false
 ) => {
-  collateralCoinNames = collateralCoinNames || [...SUPPORT_COLLATERALS];
   const marketId = query.address.get('core.market');
-  const [marketObjectResponse, coinPrices] = await Promise.all([
-    await query.cache.queryGetObject(marketId, {
-      showContent: true,
-    }),
-    await query.utils.getCoinPrices(collateralCoinNames ?? []),
-  ]);
+  const coinPrices =
+    (await query.utils.getCoinPrices(collateralCoinNames)) ?? {};
   const marketCollaterals: MarketCollaterals = {};
 
   if (indexer) {
     const marketCollateralsIndexer = await query.indexer.getMarketCollaterals();
-    for (const marketCollateral of Object.values(marketCollateralsIndexer)) {
-      if (!collateralCoinNames.includes(marketCollateral.coinName)) continue;
+    const updateMarketCollateral = (marketCollateral: MarketCollateral) => {
+      if (!collateralCoinNames.includes(marketCollateral.coinName)) return;
       marketCollateral.coinPrice =
         coinPrices[marketCollateral.coinName] || marketCollateral.coinPrice;
       marketCollateral.coinWrappedType = query.utils.getCoinWrappedType(
         marketCollateral.coinName
       );
       marketCollaterals[marketCollateral.coinName] = marketCollateral;
-    }
+    };
+    Object.values(marketCollateralsIndexer).forEach(updateMarketCollateral);
     return marketCollaterals;
   }
 
+  const marketObjectResponse = await query.cache.queryGetObject(marketId, {
+    showContent: true,
+  });
   await Promise.allSettled(
     collateralCoinNames.map(async (collateralCoinName) => {
       const marketCollateral = await getMarketCollateral(
@@ -570,6 +576,12 @@ export const getMarketCollateral = async (
   marketObject?: SuiObjectData | null,
   coinPrice?: number
 ) => {
+  coinPrice =
+    coinPrice ||
+    (await query.utils.getCoinPrices([collateralCoinName]))?.[
+      collateralCoinName
+    ];
+
   if (indexer) {
     const marketCollateralIndexer =
       await query.indexer.getMarketCollateral(collateralCoinName);
@@ -595,12 +607,6 @@ export const getMarketCollateral = async (
       })
     )?.data;
 
-  coinPrice =
-    coinPrice ||
-    (await query.utils.getCoinPrices([collateralCoinName]))?.[
-      collateralCoinName
-    ];
-
   if (marketObject) {
     if (marketObject.content && 'fields' in marketObject.content) {
       const fields = marketObject.content.fields as any;

package/src/queries/spoolQuery.ts

@@ -31,10 +31,9 @@ import type {
  */
 export const getSpools = async (
   query: ScallopQuery,
-  stakeMarketCoinNames?: SupportStakeMarketCoins[],
+  stakeMarketCoinNames: SupportStakeMarketCoins[] = [...SUPPORT_SPOOLS],
   indexer: boolean = false
 ) => {
-  stakeMarketCoinNames = stakeMarketCoinNames || [...SUPPORT_SPOOLS];
   const stakeCoinNames = stakeMarketCoinNames.map((stakeMarketCoinName) =>
     query.utils.parseCoinName<SupportStakeCoins>(stakeMarketCoinName)
   );
@@ -43,17 +42,18 @@ export const getSpools = async (
       query.utils.getSpoolRewardCoinName(stakeMarketCoinName);
     return rewardCoinName;
   });
-  const coinPrices = await query.utils.getCoinPrices(
-    [...new Set([...stakeCoinNames, ...rewardCoinNames])] ?? []
-  );
+  const coinPrices =
+    (await query.utils.getCoinPrices([
+      ...new Set([...stakeCoinNames, ...rewardCoinNames]),
+    ])) ?? {};
 
   const marketPools = await query.getMarketPools(stakeCoinNames, indexer);
   const spools: Spools = {};
 
   if (indexer) {
     const spoolsIndexer = await query.indexer.getSpools();
-    for (const spool of Object.values(spoolsIndexer)) {
-      if (!stakeMarketCoinNames.includes(spool.marketCoinName)) continue;
+    const updateSpools = (spool: Spool) => {
+      if (!stakeMarketCoinNames.includes(spool.marketCoinName)) return;
       const coinName = query.utils.parseCoinName<SupportStakeCoins>(
         spool.marketCoinName
       );
@@ -68,7 +68,8 @@ export const getSpools = async (
       spool.rewardCoinPrice =
         coinPrices[rewardCoinName] || spool.rewardCoinPrice;
       spools[spool.marketCoinName] = spool;
-    }
+    };
+    Object.values(spoolsIndexer).forEach(updateSpools);
 
     // console.log(spools);
     return spools;
@@ -117,6 +118,7 @@ export const getSpool = async (
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
   let spool: Spool | undefined = undefined;
+  coinPrices = coinPrices || (await query.utils.getCoinPrices([coinName]));
 
   if (indexer) {
     const spoolIndexer = await query.indexer.getSpool(marketCoinName);