@scallop-io/sui-scallop-sdk 0.44.1 → 0.44.3

package/src/queries/coreQuery.ts

@@ -59,6 +59,17 @@ export const queryMarket = async (query: ScallopQuery) => {
   const collaterals: MarketCollaterals = {};
 
   for (const pool of marketData.pools) {
+    const coinType = '0x' + pool.type.name;
+    const poolCoinName =
+      query.utils.parseCoinNameFromType<SupportPoolCoins>(coinType);
+    const coinPrice =
+      (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ?? 0;
+
+    // Filter pools not yet supported by the SDK.
+    if (!SUPPORT_POOLS.includes(poolCoinName)) {
+      continue;
+    }
+
     const parsedMarketPoolData = parseOriginMarketPoolData({
       type: pool.type,
       maxBorrowRate: pool.maxBorrowRate,
@@ -85,12 +96,6 @@ export const queryMarket = async (query: ScallopQuery) => {
       parsedMarketPoolData
     );
 
-    const coinType = '0x' + pool.type.name;
-    const poolCoinName =
-      query.utils.parseCoinNameFromType<SupportPoolCoins>(coinType);
-    const coinPrice =
-      (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ?? 0;
-
     pools[poolCoinName] = {
       coinName: poolCoinName,
       symbol: query.utils.parseSymbol(poolCoinName),
@@ -110,6 +115,19 @@ export const queryMarket = async (query: ScallopQuery) => {
   }
 
   for (const collateral of marketData.collaterals) {
+    const coinType = '0x' + collateral.type.name;
+    const collateralCoinName =
+      query.utils.parseCoinNameFromType<SupportCollateralCoins>(coinType);
+    const coinPrice =
+      (await query.utils.getCoinPrices([collateralCoinName]))?.[
+        collateralCoinName
+      ] ?? 0;
+
+    // Filter collaterals not yet supported by the SDK.
+    if (!SUPPORT_COLLATERALS.includes(collateralCoinName)) {
+      continue;
+    }
+
     const parsedMarketCollateralData = parseOriginMarketCollateralData({
       type: collateral.type,
       collateralFactor: collateral.collateralFactor,
@@ -126,14 +144,6 @@ export const queryMarket = async (query: ScallopQuery) => {
       parsedMarketCollateralData
     );
 
-    const coinType = '0x' + collateral.type.name;
-    const collateralCoinName =
-      query.utils.parseCoinNameFromType<SupportCollateralCoins>(coinType);
-    const coinPrice =
-      (await query.utils.getCoinPrices([collateralCoinName]))?.[
-        collateralCoinName
-      ] ?? 0;
-
     collaterals[collateralCoinName] = {
       coinName: collateralCoinName,
       symbol: query.utils.parseSymbol(collateralCoinName),
@@ -586,12 +596,44 @@ export const getObligations = async (
     if (keyObject.content && 'fields' in keyObject.content) {
       const fields = keyObject.content.fields as any;
       const obligationId = String(fields.ownership.fields.of);
-      obligations.push({ id: obligationId, keyId });
+      const locked = await getObligationLocked(query, obligationId);
+      obligations.push({ id: obligationId, keyId, locked });
     }
   }
   return obligations;
 };
 
+/**
+ * Query obligation locked status.
+ *
+ * @param query - The Scallop query instance.
+ * @param obligationId - The obligation id.
+ * @return Obligation locked status.
+ */
+export const getObligationLocked = async (
+  query: ScallopQuery,
+  obligationId: string
+) => {
+  const obligationObjectResponse = await query.suiKit.client().getObject({
+    id: obligationId,
+    options: {
+      showContent: true,
+    },
+  });
+  let obligationLocked = false;
+  if (
+    obligationObjectResponse.data &&
+    obligationObjectResponse?.data?.content?.dataType === 'moveObject' &&
+    'lock_key' in obligationObjectResponse.data.content.fields
+  ) {
+    obligationLocked = Boolean(
+      obligationObjectResponse.data.content.fields.lock_key
+    );
+  }
+
+  return obligationLocked;
+};
+
 /**
  * Query obligation data.
  *

package/src/queries/index.ts

@@ -1,4 +1,5 @@
 export * from './coreQuery';
 export * from './spoolQuery';
+export * from './borrowIncentiveQuery';
 export * from './priceQuery';
 export * from './portfolioQuery';

package/src/queries/spoolQuery.ts

@@ -1,10 +1,10 @@
 import { normalizeStructTag } from '@mysten/sui.js/utils';
 import { SUPPORT_SPOOLS } from '../constants';
 import {
-  parseOriginStakePoolData,
-  calculateStakePoolData,
-  parseOriginRewardPoolData,
-  calculateRewardPoolData,
+  parseOriginSpoolData,
+  calculateSpoolData,
+  parseOriginSpoolRewardPoolData,
+  calculateSpoolRewardPoolData,
   isMarketCoin,
 } from '../utils';
 import type { SuiObjectResponse } from '@mysten/sui.js/client';
@@ -14,7 +14,7 @@ import type {
   Spools,
   Spool,
   StakePool,
-  RewardPool,
+  StakeRewardPool,
   StakeAccounts,
   SupportStakeMarketCoins,
   SupportStakeCoins,
@@ -64,18 +64,17 @@ export const getSpools = async (
  */
 export const getSpool = async (
   query: ScallopQuery,
-  stakeMarketCoinName: SupportStakeMarketCoins,
+  marketCoinName: SupportStakeMarketCoins,
   marketPool?: MarketPool
 ) => {
-  const stakeCoinName =
-    query.utils.parseCoinName<SupportStakeCoins>(stakeMarketCoinName);
-  marketPool = marketPool || (await query.getMarketPool(stakeCoinName));
-  const poolId = query.address.get(`spool.pools.${stakeMarketCoinName}.id`);
+  const coinName = query.utils.parseCoinName<SupportStakeCoins>(marketCoinName);
+  marketPool = marketPool || (await query.getMarketPool(coinName));
+  const poolId = query.address.get(`spool.pools.${marketCoinName}.id`);
   const rewardPoolId = query.address.get(
-    `spool.pools.${stakeMarketCoinName}.rewardPoolId`
+    `spool.pools.${marketCoinName}.rewardPoolId`
   );
   let spool: Spool | undefined = undefined;
-  const stakePoolObjectResponse = await query.suiKit.client().multiGetObjects({
+  const spoolObjectResponse = await query.suiKit.client().multiGetObjects({
     ids: [poolId, rewardPoolId],
     options: {
       showContent: true,
@@ -84,20 +83,20 @@ export const getSpool = async (
 
   if (
     marketPool &&
-    stakePoolObjectResponse[0].data &&
-    stakePoolObjectResponse[1].data
+    spoolObjectResponse[0].data &&
+    spoolObjectResponse[1].data
   ) {
-    const rewardCoin = query.utils.getRewardCoinName(stakeMarketCoinName);
+    const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
     const coinPrices = await query.utils.getCoinPrices([
-      stakeCoinName,
-      rewardCoin,
+      coinName,
+      rewardCoinName,
     ]);
 
-    const stakePoolObject = stakePoolObjectResponse[0].data;
-    const rewardPoolObject = stakePoolObjectResponse[1].data;
-    if (stakePoolObject.content && 'fields' in stakePoolObject.content) {
-      const fields = stakePoolObject.content.fields as any;
-      const parsedStakePoolData = parseOriginStakePoolData({
+    const spoolObject = spoolObjectResponse[0].data;
+    const rewardPoolObject = spoolObjectResponse[1].data;
+    if (spoolObject.content && 'fields' in spoolObject.content) {
+      const fields = spoolObject.content.fields as any;
+      const parsedSpoolData = parseOriginSpoolData({
         stakeType: fields.stake_type,
         maxDistributedPoint: fields.max_distributed_point,
         distributedPoint: fields.distributed_point,
@@ -110,19 +109,18 @@ export const getSpool = async (
         lastUpdate: fields.last_update,
       });
 
-      const stakeMarketCoinPrice =
-        (coinPrices?.[stakeCoinName] ?? 0) * marketPool.conversionRate;
-      const stakeMarketCoinDecimal =
-        query.utils.getCoinDecimal(stakeMarketCoinName);
-      const calculatedStakePoolData = calculateStakePoolData(
-        parsedStakePoolData,
-        stakeMarketCoinPrice,
-        stakeMarketCoinDecimal
+      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 fields = rewardPoolObject.content.fields as any;
-        const parsedRewardPoolData = parseOriginRewardPoolData({
+        const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData({
           claimed_rewards: fields.claimed_rewards,
           exchange_rate_numerator: fields.exchange_rate_numerator,
           exchange_rate_denominator: fields.exchange_rate_denominator,
@@ -130,31 +128,38 @@ export const getSpool = async (
           spool_id: fields.spool_id,
         });
 
-        const rewardCoinPrice = coinPrices?.[rewardCoin] ?? 0;
-        const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoin);
+        const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+        const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
 
-        const calculatedRewardPoolData = calculateRewardPoolData(
-          parsedStakePoolData,
-          parsedRewardPoolData,
-          calculatedStakePoolData,
+        const calculatedRewardPoolData = calculateSpoolRewardPoolData(
+          parsedSpoolData,
+          parsedSpoolRewardPoolData,
+          calculatedSpoolData,
           rewardCoinPrice,
           rewardCoinDecimal
         );
 
         spool = {
-          marketCoinName: stakeMarketCoinName,
-          symbol: query.utils.parseSymbol(stakeMarketCoinName),
-          coinType: query.utils.parseCoinType(stakeCoinName),
-          marketCoinType: query.utils.parseMarketCoinType(stakeCoinName),
-          rewardCoinType: isMarketCoin(rewardCoin)
-            ? query.utils.parseMarketCoinType(rewardCoin)
-            : query.utils.parseCoinType(rewardCoin),
-          coinDecimal: query.utils.getCoinDecimal(stakeCoinName),
-          rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoin),
-          coinPrice: coinPrices?.[stakeCoinName] ?? 0,
-          marketCoinPrice: stakeMarketCoinPrice,
+          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),
+          coinDecimal: query.utils.getCoinDecimal(coinName),
+          rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoinName),
+          coinPrice: coinPrices?.[coinName] ?? 0,
+          marketCoinPrice: marketCoinPrice,
           rewardCoinPrice: rewardCoinPrice,
-          ...calculatedStakePoolData,
+          maxPoint: parsedSpoolData.maxPoint,
+          distributedPoint: parsedSpoolData.distributedPoint,
+          maxStake: parsedSpoolData.maxStake,
+          ...calculatedSpoolData,
+          exchangeRateNumerator:
+            parsedSpoolRewardPoolData.exchangeRateNumerator,
+          exchangeRateDenominator:
+            parsedSpoolRewardPoolData.exchangeRateDenominator,
           ...calculatedRewardPoolData,
         };
       }
@@ -281,6 +286,10 @@ export const getStakeAccounts = async (
 /**
  * Get stake pool data.
  *
+ * @description
+ * For backward compatible, it is recommended to use `getSpool` method
+ * to get stake pool info in spool data.
+ *
  * @param query - The Scallop query instance.
  * @param marketCoinName - Specific support stake market coin name.
  * @return Stake pool data.
@@ -334,39 +343,46 @@ export const getStakePool = async (
 };
 
 /**
- * Get reward pool of the owner.
+ * Get stake reward pool of the owner.
+ *
+ * @description
+ * For backward compatible, it is recommended to use `getSpool` method
+ * to get reward info in spool data.
  *
  * @param query - The Scallop query instance.
  * @param marketCoinName - Specific support stake market coin name.
- * @return Reward pool.
+ * @return Stake reward pool.
  */
-export const getRewardPool = async (
+export const getStakeRewardPool = async (
   query: ScallopQuery,
   marketCoinName: SupportStakeMarketCoins
 ) => {
   const poolId = query.address.get(
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
-  let rewardPool: RewardPool | undefined = undefined;
-  const rewardPoolObjectResponse = await query.suiKit.client().getObject({
+  let stakeRewardPool: StakeRewardPool | undefined = undefined;
+  const stakeRewardPoolObjectResponse = await query.suiKit.client().getObject({
     id: poolId,
     options: {
       showContent: true,
       showType: true,
     },
   });
-  if (rewardPoolObjectResponse.data) {
-    const rewardPoolObject = rewardPoolObjectResponse.data;
-    const id = rewardPoolObject.objectId;
-    const type = rewardPoolObject.type!;
-    if (rewardPoolObject.content && 'fields' in rewardPoolObject.content) {
-      const fields = rewardPoolObject.content.fields as any;
+  if (stakeRewardPoolObjectResponse.data) {
+    const stakeRewardPoolObject = stakeRewardPoolObjectResponse.data;
+    const id = stakeRewardPoolObject.objectId;
+    const type = stakeRewardPoolObject.type!;
+    if (
+      stakeRewardPoolObject.content &&
+      'fields' in stakeRewardPoolObject.content
+    ) {
+      const fields = stakeRewardPoolObject.content.fields as any;
       const stakePoolId = String(fields.spool_id);
       const ratioNumerator = Number(fields.exchange_rate_numerator);
       const ratioDenominator = Number(fields.exchange_rate_denominator);
       const rewards = Number(fields.rewards);
       const claimedRewards = Number(fields.claimed_rewards);
-      rewardPool = {
+      stakeRewardPool = {
         id,
         type,
         stakePoolId,
@@ -377,5 +393,5 @@ export const getRewardPool = async (
       };
     }
   }
-  return rewardPool;
+  return stakeRewardPool;
 };

package/src/types/address.ts

@@ -1,6 +1,6 @@
 import { SUPPORT_ORACLES } from '../constants';
 import type {
-  SupportCoins,
+  SupportAssetCoins,
   SupportOracleType,
   SupportPackageType,
   SupportStakeMarketCoins,
@@ -13,9 +13,10 @@ export interface AddressesInterface {
     market: string;
     adminCap: string;
     coinDecimalsRegistry: string;
+    obligationAccessStore: string;
     coins: Partial<
       Record<
-        SupportCoins,
+        SupportAssetCoins,
         {
           id: string;
           treasury: string;
@@ -80,6 +81,13 @@ export interface AddressesInterface {
       >
     >;
   };
+  borrowIncentive: {
+    id: string;
+    adminCap: string;
+    query: string;
+    incentivePools: string;
+    incentiveAccounts: string;
+  };
 }
 
 type AddressPathsProps<T> = T extends string

package/src/types/builder/borrowIncentive.ts

@@ -0,0 +1,67 @@
+import type {
+  SuiTxBlock as SuiKitTxBlock,
+  SuiAddressArg,
+} from '@scallop-io/sui-kit';
+import type { TransactionResult } from '@mysten/sui.js/transactions';
+import type { ScallopBuilder } from '../../models';
+import type { SupportBorrowIncentiveCoins } from '../constant';
+
+export type BorrowIncentiveIds = {
+  borrowIncentivePkg: string;
+  query: string;
+  incentivePools: string;
+  incentiveAccounts: string;
+  obligationAccessStore: string;
+};
+
+export type BorrowIncentiveNormalMethods = {
+  stakeObligation: (
+    obligation: SuiAddressArg,
+    obligaionKey: SuiAddressArg,
+    coinName: SupportBorrowIncentiveCoins
+  ) => void;
+  unstakeObligation: (
+    obligation: SuiAddressArg,
+    obligaionKey: SuiAddressArg,
+    coinName: SupportBorrowIncentiveCoins
+  ) => void;
+  claimBorrowIncentive: (
+    obligation: SuiAddressArg,
+    obligaionKey: SuiAddressArg,
+    coinName: SupportBorrowIncentiveCoins
+  ) => TransactionResult;
+};
+
+export type BorrowIncentiveQuickMethods = {
+  stakeObligationQuick(
+    coinName: SupportBorrowIncentiveCoins,
+    obligation?: SuiAddressArg,
+    obligationKey?: SuiAddressArg
+  ): Promise<void>;
+  unstakeObligationQuick(
+    coinName: SupportBorrowIncentiveCoins,
+    obligation?: SuiAddressArg,
+    obligationKey?: SuiAddressArg
+  ): Promise<void>;
+  claimBorrowIncentiveQuick(
+    coinName: SupportBorrowIncentiveCoins,
+    obligation?: SuiAddressArg,
+    obligationKey?: SuiAddressArg
+  ): Promise<TransactionResult>;
+};
+
+export type SuiTxBlockWithBorrowIncentiveNormalMethods = SuiKitTxBlock &
+  BorrowIncentiveNormalMethods;
+
+export type BorrowIncentiveTxBlock =
+  SuiTxBlockWithBorrowIncentiveNormalMethods & BorrowIncentiveQuickMethods;
+
+export type GenerateBorrowIncentiveNormalMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiKitTxBlock;
+}) => BorrowIncentiveNormalMethods;
+
+export type GenerateBorrowIncentiveQuickMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiTxBlockWithBorrowIncentiveNormalMethods;
+}) => BorrowIncentiveQuickMethods;

package/src/types/builder/index.ts

@@ -1,7 +1,11 @@
 import type { CoreTxBlock } from './core';
 import type { SpoolTxBlock } from './spool';
+import type { BorrowIncentiveTxBlock } from './borrowIncentive';
 
 export type * from './core';
 export type * from './spool';
+export type * from './borrowIncentive';
 
-export type ScallopTxBlock = CoreTxBlock & SpoolTxBlock;
+export type ScallopTxBlock = CoreTxBlock &
+  SpoolTxBlock &
+  BorrowIncentiveTxBlock;

package/src/types/builder/spool.ts

@@ -38,7 +38,6 @@ export type SpoolQuickMethods = {
     stakeMarketCoinName: SupportStakeMarketCoins,
     stakeAccountId?: SuiAddressArg
   ): Promise<void>;
-
   unstakeQuick(
     amount: number,
     stakeMarketCoinName: SupportStakeMarketCoins,

package/src/types/constant/common.ts

@@ -4,7 +4,9 @@ import {
   SUPPORT_ORACLES,
   SUPPORT_PACKAGES,
   SUPPORT_SPOOLS,
-  SUPPORT_REWARD_POOLS,
+  SUPPORT_SPOOLS_REWARDS,
+  SUPPORT_BORROW_INCENTIVE_POOLS,
+  SUPPORT_BORROW_INCENTIVE_REWARDS,
 } from '../../constants';
 
 type ParseMarketCoins<T extends string> = `s${T}`;
@@ -17,7 +19,8 @@ export type SupportCoins =
 export type SupportAssetCoins =
   | SupportPoolCoins
   | SupportCollateralCoins
-  | SupportRewardCoins;
+  | SupportStakeRewardCoins
+  | SupportBorrowIncentiveRewardCoins;
 export type SupportPoolCoins = (typeof SUPPORT_POOLS)[number];
 export type SupportCollateralCoins = (typeof SUPPORT_COLLATERALS)[number];
 export type SupportMarketCoins =
@@ -28,7 +31,11 @@ export type SupportStakeCoins = Extract<
   SupportPoolCoins,
   ParseCoins<SupportStakeMarketCoins>
 >;
-export type SupportRewardCoins = (typeof SUPPORT_REWARD_POOLS)[number];
+export type SupportStakeRewardCoins = (typeof SUPPORT_SPOOLS_REWARDS)[number];
+export type SupportBorrowIncentiveCoins =
+  (typeof SUPPORT_BORROW_INCENTIVE_POOLS)[number];
+export type SupportBorrowIncentiveRewardCoins =
+  (typeof SUPPORT_BORROW_INCENTIVE_REWARDS)[number];
 
 export type SupportOracleType = (typeof SUPPORT_ORACLES)[number];
 

package/src/types/constant/enum.ts

@@ -3,7 +3,9 @@ import {
   SupportAssetCoins,
   SupportMarketCoins,
   SupportStakeMarketCoins,
-  SupportRewardCoins,
+  SupportStakeRewardCoins,
+  SupportBorrowIncentiveCoins,
+  SupportBorrowIncentiveRewardCoins,
 } from './common';
 
 export type Coins = {
@@ -22,8 +24,12 @@ export type StakeMarketCoins = {
   [K in SupportStakeMarketCoins]: K;
 };
 
-export type RewardCoins = {
-  [key in SupportStakeMarketCoins]: SupportRewardCoins;
+export type StakeRewardCoins = {
+  [key in SupportStakeMarketCoins]: SupportStakeRewardCoins;
+};
+
+export type BorrowIncentiveRewardCoins = {
+  [key in SupportBorrowIncentiveCoins]: SupportBorrowIncentiveRewardCoins;
 };
 
 export type AssetCoinIds = {
@@ -38,3 +44,7 @@ export type WormholeCoinIds = {
     'eth' | 'btc' | 'usdc' | 'usdt' | 'apt' | 'sol'
   >]: string;
 };
+
+export type VoloCoinIds = {
+  [key in PickFromUnion<SupportAssetCoins, 'vsui'>]: string;
+};