@scallop-io/sui-scallop-sdk 0.44.2 → 0.44.4

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,
         };
       }
@@ -242,9 +247,9 @@ export const getStakeAccounts = async (
       if (normalizeStructTag(type) === stakeMarketCoinTypes.ssui) {
         stakeAccounts.ssui.push({
           id,
-          type,
+          type: normalizeStructTag(type),
           stakePoolId,
-          stakeType,
+          stakeType: normalizeStructTag(stakeType),
           staked,
           index,
           points,
@@ -253,9 +258,9 @@ export const getStakeAccounts = async (
       } else if (normalizeStructTag(type) === stakeMarketCoinTypes.susdc) {
         stakeAccounts.susdc.push({
           id,
-          type,
+          type: normalizeStructTag(type),
           stakePoolId,
-          stakeType,
+          stakeType: normalizeStructTag(stakeType),
           staked,
           index,
           points,
@@ -264,9 +269,9 @@ export const getStakeAccounts = async (
       } else if (normalizeStructTag(type) === stakeMarketCoinTypes.susdt) {
         stakeAccounts.susdt.push({
           id,
-          type,
+          type: normalizeStructTag(type),
           stakePoolId,
-          stakeType,
+          stakeType: normalizeStructTag(stakeType),
           staked,
           index,
           points,
@@ -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.
@@ -316,13 +325,13 @@ export const getStakePool = async (
       const lastUpdate = Number(fields.last_update);
       stakePool = {
         id,
-        type,
+        type: normalizeStructTag(type),
         maxPoint,
         distributedPoint,
         pointPerPeriod,
         period,
         maxStake,
-        stakeType,
+        stakeType: normalizeStructTag(stakeType),
         totalStaked,
         index,
         createdAt,
@@ -334,41 +343,48 @@ 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,
+        type: normalizeStructTag(type),
         stakePoolId,
         ratioNumerator,
         ratioDenominator,
@@ -377,5 +393,5 @@ export const getRewardPool = async (
       };
     }
   }
-  return rewardPool;
+  return stakeRewardPool;
 };

package/src/types/address.ts

@@ -13,6 +13,7 @@ export interface AddressesInterface {
     market: string;
     adminCap: string;
     coinDecimalsRegistry: string;
+    obligationAccessStore: string;
     coins: Partial<
       Record<
         SupportAssetCoins,
@@ -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 = {

package/src/types/query/borrowIncentive.ts

@@ -0,0 +1,150 @@
+import type { SupportBorrowIncentiveCoins } from '../constant';
+
+export interface BorrowIncentiveAccountKey {
+  id: string;
+  onwerId: string;
+}
+
+type OptionalKeys<T> = {
+  [K in keyof T]?: T[K];
+};
+
+export type BorrowIncentivePools = OptionalKeys<
+  Record<SupportBorrowIncentiveCoins, BorrowIncentivePool>
+>;
+
+export type BorrowIncentivePool = {
+  coinName: SupportBorrowIncentiveCoins;
+  symbol: string;
+  coinType: string;
+  rewardCoinType: string;
+  coinDecimal: number;
+  rewardCoinDecimal: number;
+  coinPrice: number;
+  rewardCoinPrice: number;
+} & Required<
+  Pick<
+    ParsedBorrowIncentivePoolData,
+    'maxPoint' | 'distributedPoint' | 'maxStake'
+  >
+> &
+  CalculatedBorrowIncentivePoolData &
+  BorrowIncentiveRewardPool;
+
+export type OriginBorrowIncentivePoolData = {
+  created_at: string;
+  distributed_point: string;
+  distributed_point_per_period: string;
+  index: string;
+  last_update: string;
+  max_distributed_point: string;
+  max_stakes: string;
+  point_distribution_time: string;
+  pool_type: {
+    name: string;
+  };
+  stakes: string;
+};
+
+export type ParsedBorrowIncentivePoolData = {
+  poolType: string;
+  maxPoint: number;
+  distributedPoint: number;
+  pointPerPeriod: number;
+  period: number;
+  maxStake: number;
+  staked: number;
+  index: number;
+  createdAt: number;
+  lastUpdate: number;
+};
+
+export type CalculatedBorrowIncentivePoolData = {
+  stakedAmount: number;
+  stakedCoin: number;
+  stakedValue: number;
+  distributedPointPerSec: number;
+  accumulatedPoints: number;
+  currentPointIndex: number;
+  currentTotalDistributedPoint: number;
+  startDate: Date;
+  endDate: Date;
+};
+
+export type BorrowIncentiveRewardPool = Required<
+  Pick<
+    ParsedBorrowIncentiveRewardPoolData,
+    'exchangeRateNumerator' | 'exchangeRateDenominator'
+  >
+> &
+  CalculatedBorrowIncentiveRewardPoolData;
+
+export type OriginBorrowIncentiveRewardPoolData = {
+  claimed_rewards: string;
+  exchange_rate_denominator: string;
+  exchange_rate_numerator: string;
+  remaining_reward: string;
+  reward_type: {
+    name: string;
+  };
+};
+
+export type ParsedBorrowIncentiveRewardPoolData = {
+  rewardType: string;
+  claimedRewards: number;
+  exchangeRateNumerator: number;
+  exchangeRateDenominator: number;
+  remainingRewards: number;
+};
+
+export type CalculatedBorrowIncentiveRewardPoolData = {
+  rewardApr: number;
+  totalRewardAmount: number;
+  totalRewardCoin: number;
+  totalRewardValue: number;
+  remaindRewardAmount: number;
+  remaindRewardCoin: number;
+  remaindRewardValue: number;
+  claimedRewardAmount: number;
+  claimedRewardCoin: number;
+  claimedRewardValue: number;
+  rewardPerSec: number;
+};
+
+export type BorrowIncentiveAccounts = OptionalKeys<
+  Record<SupportBorrowIncentiveCoins, ParsedBorrowIncentiveAccountData>
+>;
+
+export type OriginBorrowIncentiveAccountData = {
+  amount: string;
+  index: string;
+  points: string;
+  pool_type: {
+    name: string;
+  };
+  total_points: string;
+};
+
+export type ParsedBorrowIncentiveAccountData = {
+  poolType: string;
+  amount: number;
+  index: number;
+  points: number;
+  totalPoints: number;
+};
+
+/**
+ * The query interface for `incentive_pools_query::incentive_pools_data` inspectTxn.
+ */
+export interface BorrowIncentivePoolsQueryInterface {
+  incentive_pools: OriginBorrowIncentivePoolData[];
+  reward_pool: OriginBorrowIncentiveRewardPoolData;
+}
+
+/**
+ * The query interface for `incentive_account_query::incentive_account_data` inspectTxn.
+ */
+export interface BorrowIncentiveAccountsQueryInterface {
+  incentive_states: OriginBorrowIncentiveAccountData[];
+  total_points: string;
+}

package/src/types/query/core.ts

@@ -255,7 +255,7 @@ export type Market = {
   data?: MarketQueryInterface;
 };
 
-export type Obligation = { id: string; keyId: string };
+export type Obligation = { id: string; keyId: string; locked: boolean };
 
 /**
  * The query interface for `market_query::market_data` inspectTxn.

package/src/types/query/index.ts

@@ -1,3 +1,4 @@
 export type * from './core';
 export type * from './spool';
+export type * from './borrowIncentive';
 export type * from './portfolio';

package/src/types/query/portfolio.ts

@@ -66,6 +66,9 @@ export type ObligationAccount = {
     Record<SupportCollateralCoins, ObligationCollateral>
   >;
   debts: OptionalKeys<Record<SupportPoolCoins, ObligationDebt>>;
+  borrowIncentives: OptionalKeys<
+    Record<SupportPoolCoins, ObligationBorrowIncentive>
+  >;
 };
 
 export type ObligationCollateral = {
@@ -102,6 +105,19 @@ export type ObligationDebt = {
   availableRepayCoin: number;
 };
 
+export type ObligationBorrowIncentive = {
+  coinName: SupportPoolCoins;
+  coinType: string;
+  rewardCoinType: string;
+  symbol: string;
+  coinDecimal: number;
+  rewardCoinDecimal: number;
+  coinPrice: number;
+  rewardCoinPrice: number;
+  availableClaimAmount: number;
+  availableClaimCoin: number;
+};
+
 export type TotalValueLocked = {
   supplyValue: number;
   borrowValue: number;