diff --git a/src/models/scallopQuery.ts b/src/models/scallopQuery.ts
index 09905e2..33e7c7c 100644
--- a/src/models/scallopQuery.ts
+++ b/src/models/scallopQuery.ts
@@ -14,11 +14,14 @@ import {
   getMarketPool,
   getMarketCollaterals,
   getMarketCollateral,
+  getSpools,
+  getSpool,
   getCoinAmounts,
   getCoinAmount,
   getMarketCoinAmounts,
   getMarketCoinAmount,
   getLendings,
+  getLending,
 } from '../queries';
 import {
   ScallopQueryParams,
@@ -239,7 +242,7 @@ export class ScallopQuery {
   }
 
   /**
-   * Get  market collateral
+   * Get market collateral
    *
    * @param coinName - Specific support coin name.
    * @return Market collateral data.
@@ -248,6 +251,26 @@ export class ScallopQuery {
     return await getMarketCollateral(this, coinName);
   }
 
+  /**
+   * Get spools data.
+   *
+   * @param marketCoinNames - Specific an array of support stake market coin name.
+   * @return Spools data.
+   */
+  public async getSpools(marketCoinNames?: SupportStakeMarketCoins[]) {
+    return await getSpools(this, marketCoinNames);
+  }
+
+  /**
+   * Get spool data.
+   *
+   * @param marketCoinName - Specific support stake market coin name.
+   * @return Spool data.
+   */
+  public async getSpool(marketCoinName: SupportStakeMarketCoins) {
+    return await getSpool(this, marketCoinName);
+  }
+
   /**
    * Get all coins amount
    *
@@ -304,6 +327,31 @@ export class ScallopQuery {
     return await getMarketCoinAmount(this, marketCoinName, ownerAddress);
   }
 
+  /**
+   * Get all lending pool dta for the user
+   *
+   * @param coinNames - Specific an array of support coin name.
+   * @param ownerAddress - The owner address.
+   * @return Lending pools data.
+   */
+  public async getLendings(
+    coinNames?: SupportPoolCoins[],
+    ownerAddress?: string
+  ) {
+    return await getLendings(this, coinNames, ownerAddress);
+  }
+
+  /**
+   * Get specific lending pool information for the user
+   *
+   * @param coinName - Specific support coin name.
+   * @param ownerAddress - The owner address.
+   * @return Lending pool data.
+   */
+  public async getLending(coinName: SupportPoolCoins, ownerAddress?: string) {
+    return await getLending(this, coinName, ownerAddress);
+  }
+
   public async getCollaterals() {
     return await getLendings(this);
   }
diff --git a/src/queries/spoolQuery.ts b/src/queries/spoolQuery.ts
index d5fad1d..3b24da7 100644
--- a/src/queries/spoolQuery.ts
+++ b/src/queries/spoolQuery.ts
@@ -1,13 +1,160 @@
 import { normalizeStructTag } from '@mysten/sui.js/utils';
+import {
+  parseOriginStakePoolData,
+  calculateStakePoolData,
+  parseOriginRewardPoolData,
+  calculateRewardPoolData,
+  isMarketCoin,
+} from '../utils';
 import type { ScallopQuery } from '../models';
 import type { SuiObjectResponse } from '@mysten/sui.js/client';
 import type {
+  MarketPool,
+  Spools,
+  Spool,
   StakePool,
   RewardPool,
-  StakeAccount,
+  StakeAccounts,
   SupportStakeMarketCoins,
   SupportCoins,
+  SupportStakeCoins,
 } from '../types';
+import { SUPPORT_SPOOLS } from 'src/constants';
+
+/**
+ * Get spools data.
+ *
+ * @param query - The Scallop query instance.
+ * @param marketCoinNames - Specific an array of support stake market coins.
+ * @return Spools data.
+ */
+export const getSpools = async (
+  query: ScallopQuery,
+  marketCoinNames?: SupportStakeMarketCoins[]
+) => {
+  marketCoinNames = marketCoinNames || [...SUPPORT_SPOOLS];
+  const coinNames = marketCoinNames.map(
+    (marketCoinName) => marketCoinName.slice(1) as SupportStakeCoins
+  );
+  const marketPool = await query.getMarketPools(coinNames);
+  const spools: Spools = {};
+  for (const marketCoinName of marketCoinNames) {
+    const coinName = marketCoinName.slice(1) as SupportStakeCoins;
+    const spool = await getSpool(query, marketCoinName, marketPool[coinName]);
+
+    if (spool) {
+      spools[marketCoinName] = spool;
+    }
+  }
+
+  return spools;
+};
+
+/**
+ * Get spool data.
+ *
+ * @param query - The Scallop query instance.
+ * @param marketCoinName - Support stake market coins.
+ * @param marketPool - The market pool data.
+ * @return Spool data.
+ */
+export const getSpool = async (
+  query: ScallopQuery,
+  marketCoinName: SupportStakeMarketCoins,
+  marketPool?: MarketPool
+) => {
+  const coinName = marketCoinName.slice(1) as SupportStakeCoins;
+  marketPool = marketPool || (await query.getMarketPool(coinName));
+  const poolId = query.address.get(`spool.pools.${marketCoinName}.id`);
+  const rewardPoolId = query.address.get(
+    `spool.pools.${marketCoinName}.rewardPoolId`
+  );
+  let sPool: Spool | undefined = undefined;
+  const stakePoolObjectResponse = await query.suiKit.client().multiGetObjects({
+    ids: [poolId, rewardPoolId],
+    options: {
+      showContent: true,
+    },
+  });
+
+  if (
+    marketPool &&
+    stakePoolObjectResponse[0].data &&
+    stakePoolObjectResponse[1].data
+  ) {
+    const coinName = marketCoinName.slice(1) as SupportStakeCoins;
+    const rewardCoin = query.utils.getRewardCoinName(marketCoinName);
+    const coinPrices = await query.utils.getCoinPrices([coinName, rewardCoin]);
+
+    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({
+        stakeType: fields.stake_type,
+        maxDistributedPoint: fields.max_distributed_point,
+        distributedPoint: fields.distributed_point,
+        distributedPointPerPeriod: fields.distributed_point_per_period,
+        pointDistributionTime: fields.point_distribution_time,
+        maxStake: fields.max_stakes,
+        stakes: fields.stakes,
+        index: fields.index,
+        createdAt: fields.created_at,
+        lastUpdate: fields.last_update,
+      });
+
+      const stakeMarketCoinPrice =
+        (coinPrices?.[coinName] ?? 0) * marketPool.conversionRate;
+      const stakeMarketCoinDecimal = query.utils.getCoinDecimal(coinName);
+      const calculatedStakePoolData = calculateStakePoolData(
+        parsedStakePoolData,
+        stakeMarketCoinPrice,
+        stakeMarketCoinDecimal
+      );
+
+      if (rewardPoolObject.content && 'fields' in rewardPoolObject.content) {
+        const fields = rewardPoolObject.content.fields as any;
+        const parsedRewardPoolData = parseOriginRewardPoolData({
+          claimed_rewards: fields.claimed_rewards,
+          exchange_rate_numerator: fields.exchange_rate_numerator,
+          exchange_rate_denominator: fields.exchange_rate_denominator,
+          rewards: fields.rewards,
+          spool_id: fields.spool_id,
+        });
+
+        const rewardCoinPrice = coinPrices?.[rewardCoin] ?? 0;
+        const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoin);
+
+        const calculatedRewardPoolData = calculateRewardPoolData(
+          parsedStakePoolData,
+          parsedRewardPoolData,
+          calculatedStakePoolData,
+          rewardCoinPrice,
+          rewardCoinDecimal
+        );
+
+        sPool = {
+          marketCoin: marketCoinName,
+          symbol: query.utils.parseSymbol(coinName),
+          coinType: query.utils.parseCoinType(coinName),
+          marketCoinType: query.utils.parseMarketCoinType(coinName),
+          rewardCoinType: isMarketCoin(rewardCoin)
+            ? query.utils.parseMarketCoinType(rewardCoin)
+            : query.utils.parseCoinType(rewardCoin),
+          coinDecimal: query.utils.getCoinDecimal(coinName),
+          rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoin),
+          coinPrice: coinPrices?.[coinName] ?? 0,
+          marketCoinPrice: stakeMarketCoinPrice,
+          rewardCoinPrice: rewardCoinPrice,
+          ...calculatedStakePoolData,
+          ...calculatedRewardPoolData,
+        };
+      }
+    }
+  }
+
+  return sPool;
+};
 
 /**
  * Get all stake accounts of the owner.
@@ -48,26 +195,25 @@ export const getStakeAccounts = async (
     }
   } while (hasNextPage);
 
-  const stakeAccounts: Record<SupportStakeMarketCoins, StakeAccount[]> = {
+  const stakeAccounts: StakeAccounts = {
     ssui: [],
     susdc: [],
     susdt: [],
   };
 
-  const stakeCointTypes: Record<SupportStakeMarketCoins, string> = Object.keys(
-    stakeAccounts
-  ).reduce(
-    (types, marketCoinName) => {
-      const coinName = marketCoinName.slice(1) as SupportCoins;
-      const marketCoinType = query.utils.parseMarketCoinType(coinName);
-
-      types[
-        marketCoinName as SupportStakeMarketCoins
-      ] = `${spoolPkgId}::spool_account::SpoolAccount<${marketCoinType}>`;
-      return types;
-    },
-    {} as Record<SupportStakeMarketCoins, string>
-  );
+  const stakeMarketCoinTypes: Record<SupportStakeMarketCoins, string> =
+    Object.keys(stakeAccounts).reduce(
+      (types, marketCoinName) => {
+        const coinName = marketCoinName.slice(1) as SupportCoins;
+        const marketCoinType = query.utils.parseMarketCoinType(coinName);
+
+        types[
+          marketCoinName as SupportStakeMarketCoins
+        ] = `${spoolPkgId}::spool_account::SpoolAccount<${marketCoinType}>`;
+        return types;
+      },
+      {} as Record<SupportStakeMarketCoins, string>
+    );
 
   const stakeObjectIds: string[] = stakeObjectsResponse
     .map((ref: any) => ref?.data?.objectId)
@@ -84,7 +230,7 @@ export const getStakeAccounts = async (
       const index = Number(fields.index);
       const points = Number(fields.points);
       const totalPoints = Number(fields.total_points);
-      if (normalizeStructTag(type) === stakeCointTypes.ssui) {
+      if (normalizeStructTag(type) === stakeMarketCoinTypes.ssui) {
         stakeAccounts.ssui.push({
           id,
           type,
@@ -95,7 +241,7 @@ export const getStakeAccounts = async (
           points,
           totalPoints,
         });
-      } else if (normalizeStructTag(type) === stakeCointTypes.susdc) {
+      } else if (normalizeStructTag(type) === stakeMarketCoinTypes.susdc) {
         stakeAccounts.susdc.push({
           id,
           type,
@@ -106,7 +252,7 @@ export const getStakeAccounts = async (
           points,
           totalPoints,
         });
-      } else if (normalizeStructTag(type) === stakeCointTypes.susdt) {
+      } else if (normalizeStructTag(type) === stakeMarketCoinTypes.susdt) {
         stakeAccounts.susdt.push({
           id,
           type,
diff --git a/src/types/query/spool.ts b/src/types/query/spool.ts
index 995ba0e..b3537ab 100644
--- a/src/types/query/spool.ts
+++ b/src/types/query/spool.ts
@@ -1,4 +1,4 @@
-import { SupportStakeMarketCoins } from '../constant';
+import type { SupportStakeMarketCoins } from '../constant';
 
 type OptionalKeys<T> = {
   [K in keyof T]?: T[K];
@@ -10,6 +10,83 @@ export type StakePools = OptionalKeys<
 export type RewardPools = OptionalKeys<
   Record<SupportStakeMarketCoins, RewardPool>
 >;
+export type StakeAccounts = Record<SupportStakeMarketCoins, StakeAccount[]>;
+export type Spools = OptionalKeys<Record<SupportStakeMarketCoins, Spool>>;
+
+export type Spool = {
+  marketCoin: SupportStakeMarketCoins;
+  symbol: String;
+  coinType: string;
+  marketCoinType: string;
+  rewardCoinType: string;
+  coinDecimal: number;
+  rewardCoinDecimal: number;
+  coinPrice: number;
+  marketCoinPrice: number;
+  rewardCoinPrice: number;
+} & CalculatedStakePoolData &
+  CalculatedRewardPoolData;
+
+export type OriginStakePoolData = {
+  stakeType: { fields: { name: string } };
+  maxDistributedPoint: string;
+  distributedPoint: string;
+  distributedPointPerPeriod: string;
+  pointDistributionTime: string;
+  maxStake: string;
+  stakes: string;
+  index: string;
+  createdAt: string;
+  lastUpdate: string;
+};
+
+export type ParsedStakePoolData = {
+  stakeType: string;
+  maxPoint: number;
+  distributedPoint: number;
+  pointPerPeriod: number;
+  period: number;
+  maxStake: number;
+  totalStaked: number;
+  index: number;
+  createdAt: number;
+  lastUpdate: number;
+};
+
+export type CalculatedStakePoolData = {
+  totalStakedValue: number;
+  distributedPointPerSec: number;
+  accumulatedPoints: number;
+  currentPointIndex: number;
+  currentTotalDistributedPoint: number;
+  startDate: Date;
+  endDate: Date;
+};
+
+export type OriginRewardPoolData = {
+  claimed_rewards: string;
+  exchange_rate_denominator: string;
+  exchange_rate_numerator: string;
+  rewards: string;
+  spool_id: string;
+};
+
+export type ParsedRewardPoolData = {
+  claimedRewards: number;
+  exchangeRateNumerator: number;
+  exchangeRateDenominator: number;
+  rewards: number;
+  spoolId: string;
+};
+
+export type CalculatedRewardPoolData = {
+  stakeApr: number;
+  totalReward: number;
+  totalRewardValue: number;
+  rewardPerSec: number;
+  exchangeRateNumerator: number;
+  exchangeRateDenominator: number;
+};
 
 export interface StakeAccount {
   id: string;
diff --git a/src/utils/query.ts b/src/utils/query.ts
index a95068c..1ed450e 100644
--- a/src/utils/query.ts
+++ b/src/utils/query.ts
@@ -5,6 +5,12 @@ import type {
   CalculatedMarketPoolData,
   OriginMarketCollateralData,
   ParsedMarketCollateralData,
+  OriginStakePoolData,
+  ParsedStakePoolData,
+  CalculatedStakePoolData,
+  OriginRewardPoolData,
+  ParsedRewardPoolData,
+  CalculatedRewardPoolData,
 } from '../types';
 import { ScallopUtils } from 'src/models';
 
@@ -157,3 +163,148 @@ export const parseOriginMarketCollateralData = (
     ),
   };
 };
+
+/**
+ *  Parse origin stake pool data to a more readable format.
+ *
+ * @param originStakePoolData - Origin stake pool data
+ * @return Parsed stake pool data
+ */
+export const parseOriginStakePoolData = (
+  originStakePoolData: OriginStakePoolData
+): ParsedStakePoolData => {
+  return {
+    stakeType: originStakePoolData.stakeType.fields.name,
+    maxPoint: Number(originStakePoolData.maxDistributedPoint),
+    distributedPoint: Number(originStakePoolData.distributedPoint),
+    pointPerPeriod: Number(originStakePoolData.distributedPointPerPeriod),
+    period: Number(originStakePoolData.pointDistributionTime),
+    maxStake: Number(originStakePoolData.maxStake),
+    totalStaked: Number(originStakePoolData.stakes),
+    index: Number(originStakePoolData.index),
+    createdAt: Number(originStakePoolData.createdAt),
+    lastUpdate: Number(originStakePoolData.lastUpdate),
+  };
+};
+
+export const calculateStakePoolData = (
+  parsedStakePoolData: ParsedStakePoolData,
+  stakeMarketCoinPrice: number,
+  stakeMarketCoinDecimal: number
+): CalculatedStakePoolData => {
+  const baseIndexRate = 1_000_000_000;
+
+  const distributedPointPerSec = BigNumber(
+    parsedStakePoolData.pointPerPeriod
+  ).dividedBy(parsedStakePoolData.period);
+
+  const pointPerSec = BigNumber(parsedStakePoolData.pointPerPeriod).dividedBy(
+    parsedStakePoolData.period
+  );
+  const remainingPeriod = BigNumber(parsedStakePoolData.maxPoint)
+    .minus(parsedStakePoolData.distributedPoint)
+    .dividedBy(pointPerSec);
+  const startDate = parsedStakePoolData.createdAt;
+  const endDate = remainingPeriod
+    .plus(parsedStakePoolData.lastUpdate)
+    .integerValue()
+    .toNumber();
+
+  const timeDelta = BigNumber(
+    Math.floor(new Date().getTime() / 1000) - parsedStakePoolData.lastUpdate
+  )
+    .dividedBy(parsedStakePoolData.period)
+    .toFixed(0);
+  const remainingPoints = BigNumber(parsedStakePoolData.maxPoint).minus(
+    parsedStakePoolData.distributedPoint
+  );
+  const accumulatedPoints = BigNumber.minimum(
+    BigNumber(timeDelta).multipliedBy(parsedStakePoolData.pointPerPeriod),
+    remainingPoints
+  );
+
+  const currentPointIndex = BigNumber(parsedStakePoolData.index).plus(
+    accumulatedPoints.dividedBy(parsedStakePoolData.totalStaked).isFinite()
+      ? BigNumber(baseIndexRate)
+          .multipliedBy(accumulatedPoints)
+          .dividedBy(parsedStakePoolData.totalStaked)
+      : 0
+  );
+  const currentTotalDistributedPoint = BigNumber(
+    parsedStakePoolData.distributedPoint
+  ).plus(accumulatedPoints);
+
+  const totalStakedValue = BigNumber(parsedStakePoolData.totalStaked)
+    .shiftedBy(-1 * stakeMarketCoinDecimal)
+    .multipliedBy(stakeMarketCoinPrice);
+
+  return {
+    distributedPointPerSec: distributedPointPerSec.toNumber(),
+    accumulatedPoints: accumulatedPoints.toNumber(),
+    currentPointIndex: currentPointIndex.toNumber(),
+    currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
+    startDate: new Date(startDate * 1000),
+    endDate: new Date(endDate * 1000),
+    totalStakedValue: totalStakedValue.toNumber(),
+  };
+};
+
+/**
+ *  Parse origin reward pool data to a more readable format.
+ *
+ * @param originRewardPoolData - Origin reward pool data
+ * @return Parsed reward pool data
+ */
+export const parseOriginRewardPoolData = (
+  originRewardPoolData: OriginRewardPoolData
+): ParsedRewardPoolData => {
+  return {
+    claimedRewards: Number(originRewardPoolData.claimed_rewards),
+    exchangeRateNumerator: Number(originRewardPoolData.exchange_rate_numerator),
+    exchangeRateDenominator: Number(
+      originRewardPoolData.exchange_rate_denominator
+    ),
+    rewards: Number(originRewardPoolData.rewards),
+    spoolId: String(originRewardPoolData.spool_id),
+  };
+};
+
+export const calculateRewardPoolData = (
+  parsedStakePoolData: ParsedStakePoolData,
+  parsedRewardPoolData: ParsedRewardPoolData,
+  calculatedStakePoolData: CalculatedStakePoolData,
+  rewardCoinPrice: number,
+  rewardCoinDecimal: number
+): CalculatedRewardPoolData => {
+  const rateYearFactor = 365 * 24 * 60 * 60;
+
+  const totalReward = BigNumber(parsedStakePoolData.maxPoint)
+    .multipliedBy(parsedRewardPoolData.exchangeRateNumerator)
+    .dividedBy(parsedRewardPoolData.exchangeRateDenominator);
+
+  const rewardPerSec = BigNumber(calculatedStakePoolData.distributedPointPerSec)
+    .multipliedBy(parsedRewardPoolData.exchangeRateNumerator)
+    .dividedBy(parsedRewardPoolData.exchangeRateDenominator);
+
+  const totalRewardValue = BigNumber(rewardPerSec)
+    .shiftedBy(-1 * rewardCoinDecimal)
+    .multipliedBy(rateYearFactor)
+    .multipliedBy(rewardCoinPrice);
+
+  const stakeRate = totalRewardValue
+    .dividedBy(calculatedStakePoolData.totalStakedValue)
+    .isFinite()
+    ? totalRewardValue
+        .dividedBy(calculatedStakePoolData.totalStakedValue)
+        .toNumber()
+    : Infinity;
+
+  return {
+    stakeApr: stakeRate,
+    totalReward: totalReward.toNumber(),
+    totalRewardValue: totalRewardValue.toNumber(),
+    rewardPerSec: rewardPerSec.toNumber(),
+    exchangeRateNumerator: parsedRewardPoolData.exchangeRateNumerator,
+    exchangeRateDenominator: parsedRewardPoolData.exchangeRateDenominator,
+  };
+};
diff --git a/src/utils/util.ts b/src/utils/util.ts
index 30825ad..4a95934 100644
--- a/src/utils/util.ts
+++ b/src/utils/util.ts
@@ -1,10 +1,22 @@
-import { SUPPORT_POOLS, SUPPORT_COLLATERALS } from '../constants';
-import type { SupportCoins, SupportMarketCoins } from '../types';
+import {
+  SUPPORT_POOLS,
+  SUPPORT_COLLATERALS,
+  SUPPORT_REWARD_POOLS,
+} from '../constants';
+import type {
+  SupportCoins,
+  SupportMarketCoins,
+  SupportRewardCoins,
+} from '../types';
 
 export const isMarketCoin = (
-  coin: SupportCoins | SupportMarketCoins
+  coin: SupportCoins | SupportMarketCoins | SupportRewardCoins
 ): coin is SupportMarketCoins => {
-  return [...new Set([...SUPPORT_POOLS, ...SUPPORT_COLLATERALS])].includes(
-    coin.slice(1) as SupportCoins
-  );
+  return [
+    ...new Set([
+      ...SUPPORT_POOLS,
+      ...SUPPORT_COLLATERALS,
+      ...SUPPORT_REWARD_POOLS,
+    ]),
+  ].includes(coin.slice(1) as SupportCoins);
 };
diff --git a/test/query.spec.ts b/test/query.spec.ts
index 1299d82..c5fd817 100644
--- a/test/query.spec.ts
+++ b/test/query.spec.ts
@@ -16,7 +16,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
   });
   const scallopQuery = await scallopSDK.createScallopQuery();
 
-  it('Should query market data', async () => {
+  it.skip('Should query market data', async () => {
     const market = await scallopQuery.queryMarket();
     if (ENABLE_LOG) {
       console.info('Market:');
@@ -25,7 +25,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!market).toBe(true);
   });
 
-  it('Should get obligations and its all obligation data', async () => {
+  it.skip('Should get obligations and its all obligation data', async () => {
     const obligations = await scallopQuery.getObligations();
 
     if (ENABLE_LOG) {
@@ -45,7 +45,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     }
   });
 
-  it('Should get all stake accounts data', async () => {
+  it.skip('Should get all stake accounts data', async () => {
     const allStakeAccounts = await scallopQuery.getAllStakeAccounts();
 
     if (ENABLE_LOG) {
@@ -55,7 +55,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!allStakeAccounts).toBe(true);
   });
 
-  it('Should get all stake pool data', async () => {
+  it.skip('Should get all stake pool data', async () => {
     const stakePools = await scallopQuery.getStakePools();
 
     if (ENABLE_LOG) {
@@ -65,7 +65,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!stakePools).toBe(true);
   });
 
-  it('Should get stake pool data', async () => {
+  it.skip('Should get stake pool data', async () => {
     const suiStakePool = await scallopQuery.getStakePool('ssui');
 
     if (ENABLE_LOG) {
@@ -75,7 +75,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!suiStakePool).toBe(true);
   });
 
-  it('Should get all reward pool data', async () => {
+  it.skip('Should get all reward pool data', async () => {
     for (const marketCoinName of SUPPORT_SPOOLS) {
       const rewardPool = await scallopQuery.getRewardPool(marketCoinName);
 
@@ -88,7 +88,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     }
   });
 
-  it('Should get pyth price data', async () => {
+  it.skip('Should get pyth price data', async () => {
     const coinName = 'usdc';
     const usdcPrice = await scallopQuery.getPriceFromPyth(coinName);
 
@@ -99,7 +99,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(usdcPrice).toBeGreaterThan(0);
   });
 
-  it('Should get market pools data', async () => {
+  it.skip('Should get market pools data', async () => {
     const marketPools = await scallopQuery.getMarketPools();
 
     if (ENABLE_LOG) {
@@ -109,7 +109,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!marketPools).toBe(true);
   });
 
-  it('Should get market pool data', async () => {
+  it.skip('Should get market pool data', async () => {
     const suiMarketPool = await scallopQuery.getMarketPool('sui');
 
     if (ENABLE_LOG) {
@@ -119,7 +119,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!suiMarketPool).toBe(true);
   });
 
-  it('Should get market collaterals data', async () => {
+  it.skip('Should get market collaterals data', async () => {
     const marketCollaterals = await scallopQuery.getMarketCollaterals();
 
     if (ENABLE_LOG) {
@@ -129,7 +129,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!marketCollaterals).toBe(true);
   });
 
-  it('Should get market collateral data', async () => {
+  it.skip('Should get market collateral data', async () => {
     const suiMarketCollateral = await scallopQuery.getMarketCollateral('sui');
 
     if (ENABLE_LOG) {
@@ -139,7 +139,27 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!suiMarketCollateral).toBe(true);
   });
 
-  it('Should get coins amount', async () => {
+  it.skip('Should get spools data', async () => {
+    const spools = await scallopQuery.getSpools();
+
+    if (ENABLE_LOG) {
+      console.info('Spools:');
+      console.dir(spools, { depth: null, colors: true });
+    }
+    expect(!!spools).toBe(true);
+  });
+
+  it.skip('Should get spool data', async () => {
+    const ssuiSpool = await scallopQuery.getSpool('ssui');
+
+    if (ENABLE_LOG) {
+      console.info('sSUI spool:');
+      console.dir(ssuiSpool, { depth: null, colors: true });
+    }
+    expect(!!ssuiSpool).toBe(true);
+  });
+
+  it.skip('Should get coins amount', async () => {
     const coinsAmount = await scallopQuery.getCoinAmounts();
 
     if (ENABLE_LOG) {
@@ -149,7 +169,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!coinsAmount).toBe(true);
   });
 
-  it('Should get coin amount', async () => {
+  it.skip('Should get coin amount', async () => {
     const coinAmount = await scallopQuery.getCoinAmount('sui');
 
     if (ENABLE_LOG) {
@@ -158,7 +178,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!coinAmount).toBe(true);
   });
 
-  it('Should get market coins amount', async () => {
+  it.skip('Should get market coins amount', async () => {
     const marketCoinsAmount = await scallopQuery.getMarketCoinAmounts();
 
     if (ENABLE_LOG) {
@@ -168,7 +188,7 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     expect(!!marketCoinsAmount).toBe(true);
   });
 
-  it('Should get market coin amount', async () => {
+  it.skip('Should get market coin amount', async () => {
     const marketCoinAmount = await scallopQuery.getMarketCoinAmount('ssui');
 
     if (ENABLE_LOG) {
@@ -176,4 +196,22 @@ describe('Test Query Scallop Contract On Chain Data', async () => {
     }
     expect(!!marketCoinAmount).toBe(true);
   });
+
+  it.skip('Should get user lendings data', async () => {
+    const lendings = await scallopQuery.getLendings();
+
+    if (ENABLE_LOG) {
+      console.info('User lendings:', lendings);
+    }
+    expect(!!lendings).toBe(true);
+  });
+
+  it.skip('Should get user lending data', async () => {
+    const lending = await scallopQuery.getLending('usdt');
+
+    if (ENABLE_LOG) {
+      console.info('User lending:', lending);
+    }
+    expect(!!lending).toBe(true);
+  });
 });