@scallop-io/sui-scallop-sdk 0.44.6 → 0.44.8

package/dist/index.js

@@ -34,6 +34,7 @@ __export(src_exports, {
   API_BASE_URL: () => API_BASE_URL,
   BORROW_FEE_PROTOCOL_ID: () => BORROW_FEE_PROTOCOL_ID,
   PROTOCOL_OBJECT_ID: () => PROTOCOL_OBJECT_ID,
+  SDK_API_BASE_URL: () => SDK_API_BASE_URL,
   SUPPORT_BORROW_INCENTIVE_POOLS: () => SUPPORT_BORROW_INCENTIVE_POOLS,
   SUPPORT_BORROW_INCENTIVE_REWARDS: () => SUPPORT_BORROW_INCENTIVE_REWARDS,
   SUPPORT_COLLATERALS: () => SUPPORT_COLLATERALS,
@@ -46,6 +47,7 @@ __export(src_exports, {
   ScallopAddress: () => ScallopAddress,
   ScallopBuilder: () => ScallopBuilder,
   ScallopClient: () => ScallopClient,
+  ScallopIndexer: () => ScallopIndexer,
   ScallopQuery: () => ScallopQuery,
   ScallopUtils: () => ScallopUtils,
   assetCoins: () => assetCoins,
@@ -62,6 +64,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/constants/common.ts
 var API_BASE_URL = "https://sui.api.scallop.io";
+var SDK_API_BASE_URL = "https://sui-scallop-sdk-api.vercel.app";
 var ADDRESSES_ID = "6462a088a7ace142bb6d7e9b";
 var PROTOCOL_OBJECT_ID = "0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf";
 var BORROW_FEE_PROTOCOL_ID = "0xc38f849e81cfe46d4e4320f508ea7dda42934a329d5a6571bb4c3cb6ea63f5da";
@@ -93,7 +96,7 @@ var SUPPORT_COLLATERALS = [
 ];
 var SUPPORT_SPOOLS = ["ssui", "susdc", "susdt"];
 var SUPPORT_SPOOLS_REWARDS = ["sui"];
-var SUPPORT_BORROW_INCENTIVE_POOLS = ["sui", "usdc"];
+var SUPPORT_BORROW_INCENTIVE_POOLS = ["sui", "usdc", "usdt"];
 var SUPPORT_BORROW_INCENTIVE_REWARDS = ["sui"];
 var SUPPORT_ORACLES = ["supra", "switchboard", "pyth"];
 var SUPPORT_PACKAGES = [
@@ -174,7 +177,8 @@ var spoolRewardCoins = {
 };
 var borrowIncentiveRewardCoins = {
   sui: "sui",
-  usdc: "sui"
+  usdc: "sui",
+  usdt: "sui"
 };
 var coinIds = {
   sui: "0x0000000000000000000000000000000000000000000000000000000000000002",
@@ -1115,6 +1119,16 @@ var minBigNumber = (...args) => {
     )
   );
 };
+var estimatedFactor = (amount, scaleStep, type) => {
+  const amountOfDigits = Math.max(
+    1,
+    Math.floor(Math.log10(Math.abs(amount)) + 1)
+  );
+  const adjustScale = Math.max(Math.floor((amountOfDigits - 1) / scaleStep), 1) + 1;
+  let adjustFactor = Math.pow(10, -adjustScale);
+  adjustFactor = type === "increase" ? 1 - adjustFactor : 1 + adjustFactor;
+  return adjustFactor;
+};
 
 // src/utils/util.ts
 var isMarketCoin = (coinName) => {
@@ -1159,7 +1173,7 @@ var parseDataFromPythPriceFeed = (feed, address) => {
 };
 
 // src/queries/coreQuery.ts
-var queryMarket = async (query) => {
+var queryMarket = async (query, indexer = false) => {
   const packageId = query.address.get("core.packages.query.id");
   const marketId = query.address.get("core.market");
   const txBlock = new import_sui_kit.SuiTxBlock();
@@ -1167,12 +1181,30 @@ var queryMarket = async (query) => {
   txBlock.moveCall(queryTarget, [marketId]);
   const queryResult = await query.suiKit.inspectTxn(txBlock);
   const marketData = queryResult.events[0].parsedJson;
+  const coinPrices = await query.utils.getCoinPrices();
   const pools = {};
   const collaterals = {};
+  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
+      );
+    }
+    return {
+      pools: marketIndexer.pools,
+      collaterals: marketIndexer.collaterals
+    };
+  }
   for (const pool of marketData.pools) {
     const coinType = (0, import_utils2.normalizeStructTag)(pool.type.name);
     const poolCoinName = query.utils.parseCoinNameFromType(coinType);
-    const coinPrice = (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ?? 0;
+    const coinPrice = coinPrices[poolCoinName] ?? 0;
     if (!SUPPORT_POOLS.includes(poolCoinName)) {
       continue;
     }
@@ -1222,7 +1254,7 @@ var queryMarket = async (query) => {
   for (const collateral of marketData.collaterals) {
     const coinType = (0, import_utils2.normalizeStructTag)(collateral.type.name);
     const collateralCoinName = query.utils.parseCoinNameFromType(coinType);
-    const coinPrice = (await query.utils.getCoinPrices([collateralCoinName]))?.[collateralCoinName] ?? 0;
+    const coinPrice = coinPrices[collateralCoinName] ?? 0;
     if (!SUPPORT_COLLATERALS.includes(collateralCoinName)) {
       continue;
     }
@@ -1262,7 +1294,7 @@ var queryMarket = async (query) => {
     data: marketData
   };
 };
-var getMarketPools = async (query, poolCoinNames) => {
+var getMarketPools = async (query, poolCoinNames, indexer = false) => {
   poolCoinNames = poolCoinNames || [...SUPPORT_POOLS];
   const marketId = query.address.get("core.market");
   const marketObjectResponse = await query.suiKit.client().getObject({
@@ -1273,10 +1305,24 @@ var getMarketPools = async (query, poolCoinNames) => {
   });
   const coinPrices = await query.utils.getCoinPrices(poolCoinNames ?? []);
   const marketPools = {};
+  if (indexer) {
+    const marketPoolsIndexer = await query.indexer.getMarketPools();
+    for (const marketPool of Object.values(marketPoolsIndexer)) {
+      if (!poolCoinNames.includes(marketPool.coinName))
+        continue;
+      marketPool.coinPrice = coinPrices[marketPool.coinName] || marketPool.coinPrice;
+      marketPool.coinWrappedType = query.utils.getCoinWrappedType(
+        marketPool.coinName
+      );
+      marketPools[marketPool.coinName] = marketPool;
+    }
+    return marketPools;
+  }
   for (const poolCoinName of poolCoinNames) {
     const marketPool = await getMarketPool(
       query,
       poolCoinName,
+      indexer,
       marketObjectResponse.data,
       coinPrices?.[poolCoinName]
     );
@@ -1286,7 +1332,7 @@ var getMarketPools = async (query, poolCoinNames) => {
   }
   return marketPools;
 };
-var getMarketPool = async (query, poolCoinName, marketObject, coinPrice) => {
+var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, coinPrice) => {
   const marketId = query.address.get("core.market");
   marketObject = marketObject || (await query.suiKit.client().getObject({
     id: marketId,
@@ -1294,11 +1340,20 @@ var getMarketPool = async (query, poolCoinName, marketObject, coinPrice) => {
       showContent: true
     }
   })).data;
+  coinPrice = coinPrice || (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
   let marketPool;
   let balanceSheet;
   let borrowIndex;
   let interestModel;
   let borrowFeeRate;
+  if (indexer) {
+    const marketPoolIndexer = await query.indexer.getMarketPool(poolCoinName);
+    marketPoolIndexer.coinPrice = coinPrice || marketPoolIndexer.coinPrice;
+    marketPoolIndexer.coinWrappedType = query.utils.getCoinWrappedType(
+      marketPoolIndexer.coinName
+    );
+    return marketPoolIndexer;
+  }
   if (marketObject) {
     if (marketObject.content && "fields" in marketObject.content) {
       const fields = marketObject.content.fields;
@@ -1392,7 +1447,6 @@ var getMarketPool = async (query, poolCoinName, marketObject, coinPrice) => {
       query.utils,
       parsedMarketPoolData
     );
-    coinPrice = coinPrice || (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
     marketPool = {
       coinName: poolCoinName,
       symbol: query.utils.parseSymbol(poolCoinName),
@@ -1413,7 +1467,7 @@ var getMarketPool = async (query, poolCoinName, marketObject, coinPrice) => {
   }
   return marketPool;
 };
-var getMarketCollaterals = async (query, collateralCoinNames) => {
+var getMarketCollaterals = async (query, collateralCoinNames, indexer = false) => {
   collateralCoinNames = collateralCoinNames || [...SUPPORT_COLLATERALS];
   const marketId = query.address.get("core.market");
   const marketObjectResponse = await query.suiKit.client().getObject({
@@ -1424,10 +1478,24 @@ var getMarketCollaterals = async (query, collateralCoinNames) => {
   });
   const coinPrices = await query.utils.getCoinPrices(collateralCoinNames ?? []);
   const marketCollaterals = {};
+  if (indexer) {
+    const marketCollateralsIndexer = await query.indexer.getMarketCollaterals();
+    for (const marketCollateral of Object.values(marketCollateralsIndexer)) {
+      if (!collateralCoinNames.includes(marketCollateral.coinName))
+        continue;
+      marketCollateral.coinPrice = coinPrices[marketCollateral.coinName] || marketCollateral.coinPrice;
+      marketCollateral.coinWrappedType = query.utils.getCoinWrappedType(
+        marketCollateral.coinName
+      );
+      marketCollaterals[marketCollateral.coinName] = marketCollateral;
+    }
+    return marketCollaterals;
+  }
   for (const collateralCoinName of collateralCoinNames) {
     const marketCollateral = await getMarketCollateral(
       query,
       collateralCoinName,
+      indexer,
       marketObjectResponse.data,
       coinPrices?.[collateralCoinName]
     );
@@ -1437,7 +1505,7 @@ var getMarketCollaterals = async (query, collateralCoinNames) => {
   }
   return marketCollaterals;
 };
-var getMarketCollateral = async (query, collateralCoinName, marketObject, coinPrice) => {
+var getMarketCollateral = async (query, collateralCoinName, indexer = false, marketObject, coinPrice) => {
   const marketId = query.address.get("core.market");
   marketObject = marketObject || (await query.suiKit.client().getObject({
     id: marketId,
@@ -1445,9 +1513,18 @@ var getMarketCollateral = async (query, collateralCoinName, marketObject, coinPr
       showContent: true
     }
   })).data;
+  coinPrice = coinPrice || (await query.utils.getCoinPrices([collateralCoinName]))?.[collateralCoinName];
   let marketCollateral;
   let riskModel;
   let collateralStat;
+  if (indexer) {
+    const marketCollateralIndexer = await query.indexer.getMarketCollateral(collateralCoinName);
+    marketCollateralIndexer.coinPrice = coinPrice || marketCollateralIndexer.coinPrice;
+    marketCollateralIndexer.coinWrappedType = query.utils.getCoinWrappedType(
+      marketCollateralIndexer.coinName
+    );
+    return marketCollateralIndexer;
+  }
   if (marketObject) {
     if (marketObject.content && "fields" in marketObject.content) {
       const fields = marketObject.content.fields;
@@ -1499,7 +1576,6 @@ var getMarketCollateral = async (query, collateralCoinName, marketObject, coinPr
       query.utils,
       parsedMarketCollateralData
     );
-    coinPrice = coinPrice || (await query.utils.getCoinPrices([collateralCoinName]))?.[collateralCoinName];
     marketCollateral = {
       coinName: collateralCoinName,
       symbol: query.utils.parseSymbol(collateralCoinName),
@@ -1742,19 +1818,47 @@ var getMarketCoinAmount = async (query, marketCoinName, ownerAddress) => {
 
 // src/queries/spoolQuery.ts
 var import_utils4 = require("@mysten/sui.js/utils");
-var getSpools = async (query, stakeMarketCoinNames) => {
+var getSpools = async (query, stakeMarketCoinNames, indexer = false) => {
   stakeMarketCoinNames = stakeMarketCoinNames || [...SUPPORT_SPOOLS];
   const stakeCoinNames = stakeMarketCoinNames.map(
     (stakeMarketCoinName) => query.utils.parseCoinName(stakeMarketCoinName)
   );
-  const marketPool = await query.getMarketPools(stakeCoinNames);
+  const rewardCoinNames = stakeMarketCoinNames.map((stakeMarketCoinName) => {
+    const rewardCoinName = query.utils.getSpoolRewardCoinName(stakeMarketCoinName);
+    return rewardCoinName;
+  });
+  const coinPrices = await query.utils.getCoinPrices(
+    [.../* @__PURE__ */ new Set([...stakeCoinNames, ...rewardCoinNames])]
+  );
+  const marketPools = await query.getMarketPools(stakeCoinNames, indexer);
   const spools = {};
+  if (indexer) {
+    const spoolsIndexer = await query.indexer.getSpools();
+    for (const spool of Object.values(spoolsIndexer)) {
+      if (!stakeMarketCoinNames.includes(spool.marketCoinName))
+        continue;
+      const coinName = query.utils.parseCoinName(
+        spool.marketCoinName
+      );
+      const rewardCoinName = query.utils.getSpoolRewardCoinName(
+        spool.marketCoinName
+      );
+      const marketPool = marketPools[coinName];
+      spool.coinPrice = coinPrices[coinName] || spool.coinPrice;
+      spool.marketCoinPrice = (coinPrices[coinName] ?? 0) * (marketPool ? marketPool.conversionRate : 0) || spool.marketCoinPrice;
+      spool.rewardCoinPrice = coinPrices[rewardCoinName] || spool.rewardCoinPrice;
+      spools[spool.marketCoinName] = spool;
+    }
+    return spools;
+  }
   for (const stakeMarketCoinName of stakeMarketCoinNames) {
     const stakeCoinName = query.utils.parseCoinName(stakeMarketCoinName);
     const spool = await getSpool(
       query,
       stakeMarketCoinName,
-      marketPool[stakeCoinName]
+      indexer,
+      marketPools[stakeCoinName],
+      coinPrices
     );
     if (spool) {
       spools[stakeMarketCoinName] = spool;
@@ -1762,15 +1866,24 @@ var getSpools = async (query, stakeMarketCoinNames) => {
   }
   return spools;
 };
-var getSpool = async (query, marketCoinName, marketPool) => {
+var getSpool = async (query, marketCoinName, indexer = false, marketPool, coinPrices) => {
   const coinName = query.utils.parseCoinName(marketCoinName);
-  marketPool = marketPool || await query.getMarketPool(coinName);
+  marketPool = marketPool || await query.getMarketPool(coinName, indexer);
   const spoolPkgId = query.address.get(`spool.id`);
   const poolId = query.address.get(`spool.pools.${marketCoinName}.id`);
   const rewardPoolId = query.address.get(
     `spool.pools.${marketCoinName}.rewardPoolId`
   );
   let spool = void 0;
+  if (indexer) {
+    const spoolIndexer = await query.indexer.getSpool(marketCoinName);
+    const coinName2 = query.utils.parseCoinName(marketCoinName);
+    const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
+    spoolIndexer.coinPrice = coinPrices?.[coinName2] || spoolIndexer.coinPrice;
+    spoolIndexer.marketCoinPrice = (coinPrices?.[coinName2] ?? 0) * (marketPool ? marketPool.conversionRate : 0) || spoolIndexer.marketCoinPrice;
+    spoolIndexer.rewardCoinPrice = coinPrices?.[rewardCoinName] || spoolIndexer.rewardCoinPrice;
+    return spoolIndexer;
+  }
   const spoolObjectResponse = await query.suiKit.client().multiGetObjects({
     ids: [poolId, rewardPoolId],
     options: {
@@ -1786,10 +1899,7 @@ var getSpool = async (query, marketCoinName, marketPool) => {
   });
   if (marketPool && spoolObjectResponse[0].data && spoolObjectResponse[1].data) {
     const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
-    const coinPrices = await query.utils.getCoinPrices([
-      coinName,
-      rewardCoinName
-    ]);
+    coinPrices = coinPrices || await query.utils.getCoinPrices([coinName, rewardCoinName]);
     const spoolObject = spoolObjectResponse[0].data;
     const rewardPoolObject = spoolObjectResponse[1].data;
     const rewardFeeObject = spoolRewardFeeDynamicFieldsResponse.data;
@@ -2047,7 +2157,7 @@ var getStakeRewardPool = async (query, marketCoinName) => {
 // src/queries/borrowIncentiveQuery.ts
 var import_utils6 = require("@mysten/sui.js/utils");
 var import_sui_kit2 = require("@scallop-io/sui-kit");
-var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames) => {
+var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames, indexer = false) => {
   borrowIncentiveCoinNames = borrowIncentiveCoinNames || [
     ...SUPPORT_BORROW_INCENTIVE_POOLS
   ];
@@ -2062,18 +2172,31 @@ var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames) => {
     borrowIncentivePoolsQueryData.reward_pool
   );
   const rewardCoinType = parsedBorrowIncentiveRewardPoolData.rewardType;
+  const rewardCoinName = query.utils.parseCoinNameFromType(rewardCoinType);
+  const coinPrices = await query.utils.getCoinPrices(
+    [.../* @__PURE__ */ new Set([...borrowIncentiveCoinNames, rewardCoinName])]
+  );
   const borrowIncentivePools = {};
+  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;
+    }
+    return borrowIncentivePools;
+  }
   for (const pool of borrowIncentivePoolsQueryData.incentive_pools) {
     const coinType = (0, import_utils6.normalizeStructTag)(pool.pool_type.name);
     const coinName = query.utils.parseCoinNameFromType(coinType);
-    const rewardCoinName = query.utils.parseCoinNameFromType(rewardCoinType);
+    const rewardCoinName2 = query.utils.parseCoinNameFromType(rewardCoinType);
     if (!borrowIncentiveCoinNames.includes(coinName)) {
       continue;
     }
-    const coinPrices = await query.utils.getCoinPrices([
-      coinName,
-      rewardCoinName
-    ]);
     const parsedBorrowIncentivePoolData = parseOriginBorrowIncentivePoolData(pool);
     const coinPrice = coinPrices?.[coinName] ?? 0;
     const coinDecimal = query.utils.getCoinDecimal(coinName);
@@ -2082,8 +2205,8 @@ var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames) => {
       coinPrice,
       coinDecimal
     );
-    const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
-    const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+    const rewardCoinPrice = coinPrices?.[rewardCoinName2] ?? 0;
+    const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName2);
     const calculatedBorrowIncentiveRewardPoolData = calculateBorrowIncentiveRewardPoolData(
       parsedBorrowIncentivePoolData,
       parsedBorrowIncentiveRewardPoolData,
@@ -2179,7 +2302,7 @@ var getPythPrice = async (query, assetCoinName) => {
 
 // src/queries/portfolioQuery.ts
 var import_bignumber3 = __toESM(require("bignumber.js"));
-var getLendings = async (query, poolCoinNames, ownerAddress) => {
+var getLendings = async (query, poolCoinNames, ownerAddress, indexer = false) => {
   poolCoinNames = poolCoinNames || [...SUPPORT_POOLS];
   const marketCoinNames = poolCoinNames.map(
     (poolCoinName) => query.utils.parseMarketCoinName(poolCoinName)
@@ -2187,8 +2310,8 @@ var getLendings = async (query, poolCoinNames, ownerAddress) => {
   const stakeMarketCoinNames = marketCoinNames.filter(
     (marketCoinName) => SUPPORT_SPOOLS.includes(marketCoinName)
   );
-  const marketPools = await query.getMarketPools(poolCoinNames);
-  const spools = await query.getSpools(stakeMarketCoinNames);
+  const marketPools = await query.getMarketPools(poolCoinNames, indexer);
+  const spools = await query.getSpools(stakeMarketCoinNames, indexer);
   const coinAmounts = await query.getCoinAmounts(poolCoinNames, ownerAddress);
   const marketCoinAmounts = await query.getMarketCoinAmounts(
     marketCoinNames,
@@ -2206,6 +2329,7 @@ var getLendings = async (query, poolCoinNames, ownerAddress) => {
       query,
       poolCoinName,
       ownerAddress,
+      indexer,
       marketPools?.[poolCoinName],
       stakeMarketCoinName ? spools[stakeMarketCoinName] : void 0,
       stakeMarketCoinName ? allStakeAccounts[stakeMarketCoinName] : void 0,
@@ -2216,10 +2340,10 @@ var getLendings = async (query, poolCoinNames, ownerAddress) => {
   }
   return lendings;
 };
-var getLending = async (query, poolCoinName, ownerAddress, marketPool, spool, stakeAccounts, coinAmount, marketCoinAmount, coinPrice) => {
+var getLending = async (query, poolCoinName, ownerAddress, indexer = false, marketPool, spool, stakeAccounts, coinAmount, marketCoinAmount, coinPrice) => {
   const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
-  marketPool = marketPool || await query.getMarketPool(poolCoinName);
-  spool = spool || SUPPORT_SPOOLS.includes(marketCoinName) ? await query.getSpool(marketCoinName) : void 0;
+  marketPool = marketPool || await query.getMarketPool(poolCoinName, indexer);
+  spool = spool || SUPPORT_SPOOLS.includes(marketCoinName) ? await query.getSpool(marketCoinName, indexer) : void 0;
   stakeAccounts = stakeAccounts || SUPPORT_SPOOLS.includes(marketCoinName) ? await query.getStakeAccounts(
     marketCoinName,
     ownerAddress
@@ -2266,7 +2390,7 @@ var getLending = async (query, poolCoinName, ownerAddress, marketPool, spool, st
         -1 * spool.coinDecimal
       );
       const baseIndexRate = 1e9;
-      const increasedPointRate = spool?.currentPointIndex ? (0, import_bignumber3.default)(spool.currentPointIndex - stakeAccount.index).dividedBy(
+      const increasedPointRate = spool.currentPointIndex ? (0, import_bignumber3.default)(spool.currentPointIndex - stakeAccount.index).dividedBy(
         baseIndexRate
       ) : 1;
       availableClaimAmount = availableClaimAmount.plus(
@@ -2330,8 +2454,8 @@ var getLending = async (query, poolCoinName, ownerAddress, marketPool, spool, st
   };
   return lending;
 };
-var getObligationAccounts = async (query, ownerAddress) => {
-  const market = await query.queryMarket();
+var getObligationAccounts = async (query, ownerAddress, indexer = false) => {
+  const market = await query.queryMarket(indexer);
   const coinPrices = await query.utils.getCoinPrices();
   const coinAmounts = await query.getCoinAmounts(void 0, ownerAddress);
   const obligations = await query.getObligations(ownerAddress);
@@ -2341,6 +2465,7 @@ var getObligationAccounts = async (query, ownerAddress) => {
       query,
       obligation.id,
       ownerAddress,
+      indexer,
       market,
       coinPrices,
       coinAmounts
@@ -2348,8 +2473,8 @@ var getObligationAccounts = async (query, ownerAddress) => {
   }
   return obligationAccounts;
 };
-var getObligationAccount = async (query, obligationId, ownerAddress, market, coinPrices, coinAmounts) => {
-  market = market || await query.queryMarket();
+var getObligationAccount = async (query, obligationId, ownerAddress, indexer = false, market, coinPrices, coinAmounts) => {
+  market = market || await query.queryMarket(indexer);
   const assetCoinNames = [
     .../* @__PURE__ */ new Set([
       ...Object.values(market.pools).map((pool) => pool.coinName),
@@ -2359,7 +2484,10 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
     ])
   ];
   const obligationQuery = await query.queryObligation(obligationId);
-  const borrowIncentivePools = await query.getBorrowIncentivePools();
+  const borrowIncentivePools = await query.getBorrowIncentivePools(
+    void 0,
+    indexer
+  );
   const borrowIncentiveAccounts = await query.getBorrowIncentiveAccounts(obligationId);
   coinPrices = coinPrices || await query.utils.getCoinPrices(assetCoinNames);
   coinAmounts = coinAmounts || await query.getCoinAmounts(assetCoinNames, ownerAddress);
@@ -2380,8 +2508,8 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       );
       return assetCoinName === collateralCoinName;
     });
-    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const marketCollateral = market.collaterals[assetCoinName];
+    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const coinPrice = coinPrices?.[assetCoinName];
     const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
     if (marketCollateral && coinPrice) {
@@ -2431,20 +2559,23 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       );
       return assetCoinName === poolCoinName;
     });
-    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const marketPool = market.pools[assetCoinName];
+    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
     const coinPrice = coinPrices?.[assetCoinName];
+    const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
     if (marketPool && coinPrice) {
       const increasedRate = debt?.borrowIndex ? marketPool.borrowIndex / Number(debt.borrowIndex) - 1 : 0;
       const borrowedAmount = (0, import_bignumber3.default)(debt?.amount ?? 0);
       const borrowedCoin = borrowedAmount.shiftedBy(-1 * coinDecimal);
-      const availableRepayAmount = borrowedAmount.multipliedBy(
+      const requiredRepayAmount = borrowedAmount.multipliedBy(
         increasedRate + 1
       );
+      const requiredRepayCoin = requiredRepayAmount.shiftedBy(-1 * coinDecimal);
+      const availableRepayAmount = (0, import_bignumber3.default)(coinAmount);
       const availableRepayCoin = availableRepayAmount.shiftedBy(
         -1 * coinDecimal
       );
-      const borrowedValue = availableRepayCoin.multipliedBy(coinPrice);
+      const borrowedValue = requiredRepayCoin.multipliedBy(coinPrice);
       const borrowedValueWithWeight = borrowedValue.multipliedBy(
         marketPool.borrowWeight
       );
@@ -2466,6 +2597,8 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
         borrowedValue: borrowedValue.toNumber(),
         borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
         borrowIndex: Number(debt?.borrowIndex ?? 0),
+        requiredRepayAmount: requiredRepayAmount.toNumber(),
+        requiredRepayCoin: requiredRepayCoin.toNumber(),
         availableBorrowAmount: 0,
         availableBorrowCoin: 0,
         availableRepayAmount: availableRepayAmount.toNumber(),
@@ -2508,8 +2641,8 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       }
     }
   }
-  let riskLevel = totalRequiredCollateralValue.isZero() && totalBorrowedValueWithWeight.isZero() ? (0, import_bignumber3.default)(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
-  riskLevel = riskLevel.isFinite() ? riskLevel.isLessThan(1) ? riskLevel : (0, import_bignumber3.default)(1) : (0, import_bignumber3.default)(1);
+  let riskLevel = totalRequiredCollateralValue.isZero() ? (0, import_bignumber3.default)(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
+  riskLevel = riskLevel.isLessThan(1) ? riskLevel : (0, import_bignumber3.default)(1);
   const accountBalanceValue = totalDepositedValue.minus(totalBorrowedValue).isGreaterThan(0) ? totalDepositedValue.minus(totalBorrowedValue) : (0, import_bignumber3.default)(0);
   const availableCollateralValue = totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight).isGreaterThan(0) ? totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight) : (0, import_bignumber3.default)(0);
   const requiredCollateralValue = totalBorrowedValueWithWeight.isGreaterThan(0) ? totalRequiredCollateralValue : (0, import_bignumber3.default)(0);
@@ -2544,13 +2677,25 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
   )) {
     const marketCollateral = market.collaterals[collateralCoinName];
     if (marketCollateral) {
-      const availableWithdrawAmount = obligationAccount.totalBorrowedValueWithWeight === 0 ? (0, import_bignumber3.default)(obligationCollateral.depositedAmount) : minBigNumber(
-        (0, import_bignumber3.default)(obligationAccount.totalAvailableCollateralValue).dividedBy(marketCollateral.collateralFactor).dividedBy(marketCollateral.coinPrice).multipliedBy(0.99).toNumber(),
+      let estimatedAvailableWithdrawAmount = (0, import_bignumber3.default)(
+        obligationAccount.totalAvailableCollateralValue
+      ).dividedBy(marketCollateral.collateralFactor).dividedBy(marketCollateral.coinPrice).shiftedBy(marketCollateral.coinDecimal);
+      estimatedAvailableWithdrawAmount = obligationAccount.totalBorrowedValueWithWeight === 0 ? (
+        // Note: when there is no debt record, there is no need to estimate and the deposited amount is directly used as available withdraw.
+        (0, import_bignumber3.default)(obligationCollateral.depositedAmount)
+      ) : minBigNumber(
+        estimatedAvailableWithdrawAmount.multipliedBy(
+          estimatedFactor(
+            (0, import_bignumber3.default)(obligationAccount.totalAvailableCollateralValue).dividedBy(marketCollateral.collateralFactor).toNumber(),
+            3,
+            "increase"
+          )
+        ).toNumber(),
         obligationCollateral.depositedAmount,
         marketCollateral.depositAmount
       );
-      obligationCollateral.availableWithdrawAmount = availableWithdrawAmount.toNumber();
-      obligationCollateral.availableWithdrawCoin = availableWithdrawAmount.shiftedBy(-1 * obligationCollateral.coinDecimal).toNumber();
+      obligationCollateral.availableWithdrawAmount = estimatedAvailableWithdrawAmount.toNumber();
+      obligationCollateral.availableWithdrawCoin = estimatedAvailableWithdrawAmount.shiftedBy(-1 * obligationCollateral.coinDecimal).toNumber();
     }
   }
   for (const [poolCoinName, obligationDebt] of Object.entries(
@@ -2558,29 +2703,44 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
   )) {
     const marketPool = market.pools[poolCoinName];
     if (marketPool) {
-      const availableRepayAmount = (0, import_bignumber3.default)(
-        obligationDebt.availableRepayAmount
-      ).multipliedBy(1.01);
-      const availableBorrowAmount = obligationAccount.totalAvailableCollateralValue !== 0 ? minBigNumber(
-        (0, import_bignumber3.default)(obligationAccount.totalAvailableCollateralValue).dividedBy(
-          (0, import_bignumber3.default)(marketPool.coinPrice).multipliedBy(
-            marketPool.borrowWeight
+      const estimatedRequiredRepayAmount = (0, import_bignumber3.default)(
+        obligationDebt.requiredRepayAmount
+      ).multipliedBy(
+        estimatedFactor(obligationDebt.borrowedValue, 3, "decrease")
+      );
+      let estimatedAvailableBorrowAmount = (0, import_bignumber3.default)(
+        obligationAccount.totalAvailableCollateralValue
+      ).dividedBy(marketPool.borrowWeight).shiftedBy(marketPool.coinDecimal).dividedBy(marketPool.coinPrice);
+      estimatedAvailableBorrowAmount = obligationAccount.totalAvailableCollateralValue !== 0 ? minBigNumber(
+        estimatedAvailableBorrowAmount.multipliedBy(
+          estimatedFactor(
+            estimatedAvailableBorrowAmount.shiftedBy(-1 * marketPool.coinDecimal).multipliedBy(marketPool.coinPrice).toNumber(),
+            3,
+            "increase"
           )
-        ).multipliedBy(0.99).toNumber(),
+        ).toNumber(),
         marketPool.supplyAmount
       ) : (0, import_bignumber3.default)(0);
-      obligationDebt.availableBorrowAmount = availableBorrowAmount.toNumber();
-      obligationDebt.availableBorrowCoin = availableBorrowAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
-      obligationDebt.availableRepayAmount = availableRepayAmount.toNumber();
-      obligationDebt.availableRepayCoin = availableRepayAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
+      obligationDebt.availableBorrowAmount = estimatedAvailableBorrowAmount.toNumber();
+      obligationDebt.availableBorrowCoin = estimatedAvailableBorrowAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
+      obligationDebt.requiredRepayAmount = estimatedRequiredRepayAmount.toNumber();
+      obligationDebt.requiredRepayCoin = estimatedRequiredRepayAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
     }
   }
   return obligationAccount;
 };
-var getTotalValueLocked = async (query) => {
-  const market = await query.queryMarket();
+var getTotalValueLocked = async (query, indexer = false) => {
+  const market = await query.queryMarket(indexer);
   let supplyValue = (0, import_bignumber3.default)(0);
   let borrowValue = (0, import_bignumber3.default)(0);
+  if (indexer) {
+    const tvl2 = await query.indexer.getTotalValueLocked();
+    return {
+      supplyValue: tvl2.supplyValue,
+      borrowValue: tvl2.borrowValue,
+      totalValue: tvl2.totalValue
+    };
+  }
   for (const pool of Object.values(market.pools)) {
     supplyValue = supplyValue.plus(
       (0, import_bignumber3.default)(pool.supplyCoin).multipliedBy(pool.coinPrice)
@@ -2602,6 +2762,183 @@ var getTotalValueLocked = async (query) => {
   return tvl;
 };
 
+// src/models/scallopIndexer.ts
+var import_axios2 = __toESM(require("axios"));
+var ScallopIndexer = class {
+  constructor() {
+    this._requestClient = import_axios2.default.create({
+      baseURL: SDK_API_BASE_URL,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      timeout: 3e4
+    });
+  }
+  /**
+   * Get market index data.
+   *
+   * @return Market data.
+   */
+  async getMarket() {
+    const response = await this._requestClient.get(`${SDK_API_BASE_URL}/api/market`);
+    if (response.status === 200) {
+      return {
+        pools: response.data.pools.reduce((marketPools, marketPool) => {
+          marketPools[marketPool.coinName] = marketPool;
+          return marketPools;
+        }, {}),
+        collaterals: response.data.collaterals.reduce(
+          (marketCollaterals, marketCollateral) => {
+            marketCollaterals[marketCollateral.coinName] = marketCollateral;
+            return marketCollaterals;
+          },
+          {}
+        )
+      };
+    } else {
+      throw Error("Failed to getMarket.");
+    }
+  }
+  /**
+   * Get market pools index data.
+   *
+   * @return Market pools data.
+   */
+  async getMarketPools() {
+    const response = await this._requestClient.get(`${SDK_API_BASE_URL}/api/market/pools`);
+    if (response.status === 200) {
+      return response.data.pools.reduce((marketPools, marketPool) => {
+        marketPools[marketPool.coinName] = marketPool;
+        return marketPools;
+      }, {});
+    } else {
+      throw Error("Failed to getMarketPools.");
+    }
+  }
+  /**
+   * Get market pool index data.
+   *
+   * @return Market pool data.
+   */
+  async getMarketPool(poolCoinName) {
+    const response = await this._requestClient.get(`${SDK_API_BASE_URL}/api/market/pool/${poolCoinName}`);
+    if (response.status === 200) {
+      return response.data.pool;
+    } else {
+      throw Error("Failed to getMarketPool.");
+    }
+  }
+  /**
+   * Get market collaterals index data.
+   *
+   * @return Market collaterals data.
+   */
+  async getMarketCollaterals() {
+    const response = await this._requestClient.get(`${SDK_API_BASE_URL}/api/market/collaterals`);
+    if (response.status === 200) {
+      return response.data.collaterals.reduce(
+        (marketCollaterals, marketCollateral) => {
+          marketCollaterals[marketCollateral.coinName] = marketCollateral;
+          return marketCollaterals;
+        },
+        {}
+      );
+    } else {
+      throw Error("Failed to getMarketCollaterals.");
+    }
+  }
+  /**
+   * Get market collateral index data.
+   *
+   * @return Market collateral data.
+   */
+  async getMarketCollateral(collateralCoinName) {
+    const response = await this._requestClient.get(`${SDK_API_BASE_URL}/api/market/collateral/${collateralCoinName}`);
+    if (response.status === 200) {
+      return response.data.collateral;
+    } else {
+      throw Error("Failed to getMarketCollateral.");
+    }
+  }
+  /**
+   * Get spools index data.
+   *
+   * @return Spools data.
+   */
+  async getSpools() {
+    const response = await this._requestClient.get(`${SDK_API_BASE_URL}/api/spools`);
+    if (response.status === 200) {
+      return response.data.spools.reduce((spools, spool) => {
+        spools[spool.marketCoinName] = spool;
+        return spools;
+      }, {});
+    } else {
+      throw Error("Failed to getSpools.");
+    }
+  }
+  /**
+   * Get spool index data.
+   *
+   * @return Spool data.
+   */
+  async getSpool(marketCoinName) {
+    const response = await this._requestClient.get(`${SDK_API_BASE_URL}/api/spool/${marketCoinName}`);
+    if (response.status === 200) {
+      return response.data.spool;
+    } else {
+      throw Error("Failed to getSpool.");
+    }
+  }
+  /**
+   * Get borrow incentive pools index data.
+   *
+   * @return Borrow incentive pools data.
+   */
+  async getBorrowIncentivePools() {
+    const response = await this._requestClient.get(`${SDK_API_BASE_URL}/api/borrowIncentivePools`);
+    if (response.status === 200) {
+      return response.data.borrowIncentivePools.reduce(
+        (borrowIncentivePools, borrowIncentivePool) => {
+          borrowIncentivePools[borrowIncentivePool.coinName] = borrowIncentivePool;
+          return borrowIncentivePools;
+        },
+        {}
+      );
+    } else {
+      throw Error("Failed to getBorrowIncentivePools.");
+    }
+  }
+  /**
+   * Get borrow incentive pool index data.
+   *
+   * @return Borrow incentive pool data.
+   */
+  async getBorrowIncentivePool(borrowIncentiveCoinName) {
+    const response = await this._requestClient.get(
+      `${SDK_API_BASE_URL}/api/borrowIncentivePool/${borrowIncentiveCoinName}`
+    );
+    if (response.status === 200) {
+      return response.data.borrowIncentivePool;
+    } else {
+      throw Error("Failed to getSpool.");
+    }
+  }
+  /**
+   * Get total value locked index data.
+   *
+   * @return Total value locked.
+   */
+  async getTotalValueLocked() {
+    const response = await this._requestClient.get(`${SDK_API_BASE_URL}/api/market/tvl`);
+    if (response.status === 200) {
+      return response.data;
+    } else {
+      throw Error("Failed to getTotalValueLocked.");
+    }
+  }
+};
+
 // src/models/scallopQuery.ts
 var ScallopQuery = class {
   constructor(params, instance) {
@@ -2616,6 +2953,7 @@ var ScallopQuery = class {
       address: this.address,
       query: this
     });
+    this.indexer = new ScallopIndexer();
   }
   /**
    * Request the scallop API to initialize data.
@@ -2631,11 +2969,11 @@ var ScallopQuery = class {
   /* ==================== Core Query Methods ==================== */
   /**
    * Query market data.
-   *
+   * @param indexer - Whether to use indexer.
    * @return Market data.
    */
-  async queryMarket() {
-    return await queryMarket(this);
+  async queryMarket(indexer = false) {
+    return await queryMarket(this, indexer);
   }
   /**
    * Get market pools.
@@ -2645,19 +2983,21 @@ var ScallopQuery = class {
    * the `queryMarket` method to reduce time consumption.
    *
    * @param poolCoinNames - Specific an array of support pool coin name.
+   * @param indexer - Whether to use indexer.
    * @return Market pools data.
    */
-  async getMarketPools(poolCoinNames) {
-    return await getMarketPools(this, poolCoinNames);
+  async getMarketPools(poolCoinNames, indexer = false) {
+    return await getMarketPools(this, poolCoinNames, indexer);
   }
   /**
    * Get  market pool
    *
    * @param poolCoinName - Specific support pool coin name.
+   * @param indexer - Whether to use indexer.
    * @return Market pool data.
    */
-  async getMarketPool(poolCoinName) {
-    return await getMarketPool(this, poolCoinName);
+  async getMarketPool(poolCoinName, indexer = false) {
+    return await getMarketPool(this, poolCoinName, indexer);
   }
   /**
    * Get market collaterals.
@@ -2667,19 +3007,21 @@ var ScallopQuery = class {
    * the `queryMarket` method to reduce time consumption.
    *
    * @param collateralCoinNames - Specific an array of support collateral coin name.
+   * @param indexer - Whether to use indexer.
    * @return Market collaterals data.
    */
-  async getMarketCollaterals(collateralCoinNames) {
-    return await getMarketCollaterals(this, collateralCoinNames);
+  async getMarketCollaterals(collateralCoinNames, indexer = false) {
+    return await getMarketCollaterals(this, collateralCoinNames, indexer);
   }
   /**
    * Get market collateral
    *
    * @param collateralCoinName - Specific support collateral coin name.
+   * @param indexer - Whether to use indexer.
    * @return Market collateral data.
    */
-  async getMarketCollateral(collateralCoinName) {
-    return await getMarketCollateral(this, collateralCoinName);
+  async getMarketCollateral(collateralCoinName, indexer = false) {
+    return await getMarketCollateral(this, collateralCoinName, indexer);
   }
   /**
    * Get obligations data.
@@ -2753,19 +3095,21 @@ var ScallopQuery = class {
    * Get spools data.
    *
    * @param stakeMarketCoinNames - Specific an array of support stake market coin name.
+   * @param indexer - Whether to use indexer.
    * @return Spools data.
    */
-  async getSpools(stakeMarketCoinNames) {
-    return await getSpools(this, stakeMarketCoinNames);
+  async getSpools(stakeMarketCoinNames, indexer = false) {
+    return await getSpools(this, stakeMarketCoinNames, indexer);
   }
   /**
    * Get spool data.
    *
    * @param stakeMarketCoinName - Specific support stake market coin name.
+   * @param indexer - Whether to use indexer.
    * @return Spool data.
    */
-  async getSpool(stakeMarketCoinName) {
-    return await getSpool(this, stakeMarketCoinName);
+  async getSpool(stakeMarketCoinName, indexer = false) {
+    return await getSpool(this, stakeMarketCoinName, indexer);
   }
   /**
    * Get stake accounts data for all stake pools (spools).
@@ -2862,10 +3206,11 @@ var ScallopQuery = class {
    * Get borrow incentive pools data.
    *
    * @param coinNames - Specific an array of support borrow incentive coin name.
+   * @param indexer - Whether to use indexer.
    * @return Borrow incentive pools data.
    */
-  async getBorrowIncentivePools(coinNames) {
-    return await queryBorrowIncentivePools(this, coinNames);
+  async getBorrowIncentivePools(coinNames, indexer = false) {
+    return await queryBorrowIncentivePools(this, coinNames, indexer);
   }
   /**
    * Get borrow incentive accounts data.
@@ -2882,20 +3227,22 @@ var ScallopQuery = class {
    *
    * @param poolCoinNames - Specific an array of support pool coin name.
    * @param ownerAddress - The owner address.
+   * @param indexer - Whether to use indexer.
    * @return All lending and spool infomation.
    */
-  async getLendings(poolCoinNames, ownerAddress) {
-    return await getLendings(this, poolCoinNames, ownerAddress);
+  async getLendings(poolCoinNames, ownerAddress, indexer = false) {
+    return await getLendings(this, poolCoinNames, ownerAddress, indexer);
   }
   /**
    * Get user lending and spool information for specific pool.
    *
    * @param poolCoinName - Specific support pool coin name.
    * @param ownerAddress - The owner address.
+   * @param indexer - Whether to use indexer.
    * @return Lending pool data.
    */
-  async getLending(poolCoinName, ownerAddress) {
-    return await getLending(this, poolCoinName, ownerAddress);
+  async getLending(poolCoinName, ownerAddress, indexer = false) {
+    return await getLending(this, poolCoinName, ownerAddress, indexer);
   }
   /**
    * Get user all obligation accounts information.
@@ -2904,10 +3251,11 @@ var ScallopQuery = class {
    * All collateral and borrowing information in all obligation accounts owned by the user.
    *
    * @param ownerAddress - The owner address.
+   * @param indexer - Whether to use indexer.
    * @return All obligation accounts information.
    */
-  async getObligationAccounts(ownerAddress) {
-    return await getObligationAccounts(this, ownerAddress);
+  async getObligationAccounts(ownerAddress, indexer = false) {
+    return await getObligationAccounts(this, ownerAddress, indexer);
   }
   /**
    * Get obligation account information for specific id.
@@ -2917,21 +3265,28 @@ var ScallopQuery = class {
    *
    * @param obligationId - The obligation id.
    * @param ownerAddress - The owner address.
+   * @param indexer - Whether to use indexer.
    * @return Borrowing and collateral information.
    */
-  async getObligationAccount(obligationId, ownerAddress) {
-    return await getObligationAccount(this, obligationId, ownerAddress);
+  async getObligationAccount(obligationId, ownerAddress, indexer = false) {
+    return await getObligationAccount(
+      this,
+      obligationId,
+      ownerAddress,
+      indexer
+    );
   }
   /**
    * Get total value locked.
    *
+   * @param indexer - Whether to use indexer.
    * @description
    * Include total supplied value and total borrowed value.
    *
    * @return Total value locked.
    */
-  async getTvl() {
-    return await getTotalValueLocked(this);
+  async getTvl(indexer = false) {
+    return await getTotalValueLocked(this, indexer);
   }
 };
 
@@ -4414,6 +4769,14 @@ var ScallopClient = class {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
+    const availableStake = SUPPORT_BORROW_INCENTIVE_POOLS.includes(poolCoinName);
+    if (sign && availableStake) {
+      await txBlock.unstakeObligationQuick(
+        poolCoinName,
+        obligationId,
+        obligationKey
+      );
+    }
     const coin = await txBlock.borrowQuick(
       amount,
       poolCoinName,
@@ -4421,6 +4784,13 @@ var ScallopClient = class {
       obligationKey
     );
     txBlock.transferObjects([coin], sender);
+    if (sign && availableStake) {
+      await txBlock.stakeObligationQuick(
+        poolCoinName,
+        obligationId,
+        obligationKey
+      );
+    }
     if (sign) {
       return await this.suiKit.signAndSendTxn(
         txBlock
@@ -4439,11 +4809,26 @@ var ScallopClient = class {
    * @param walletAddress - The wallet address of the owner.
    * @return Transaction block response or transaction block.
    */
-  async repay(poolCoinName, amount, sign = true, obligationId, walletAddress) {
+  async repay(poolCoinName, amount, sign = true, obligationId, obligationKey, walletAddress) {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress || this.walletAddress;
     txBlock.setSender(sender);
+    const availableStake = SUPPORT_BORROW_INCENTIVE_POOLS.includes(poolCoinName);
+    if (sign && availableStake) {
+      await txBlock.unstakeObligationQuick(
+        poolCoinName,
+        obligationId,
+        obligationKey
+      );
+    }
     await txBlock.repayQuick(amount, poolCoinName, obligationId);
+    if (sign && availableStake) {
+      await txBlock.stakeObligationQuick(
+        poolCoinName,
+        obligationId,
+        obligationKey
+      );
+    }
     if (sign) {
       return await this.suiKit.signAndSendTxn(
         txBlock
@@ -4718,6 +5103,15 @@ var Scallop = class {
     });
     return scallopQuery;
   }
+  /**
+   * Create a scallop indexer instance.
+   *
+   * @return Scallop Indexer.
+   */
+  async createScallopIndexer() {
+    const scallopIndexer = new ScallopIndexer();
+    return scallopIndexer;
+  }
   /**
    * Create a scallop utils instance.
    *
@@ -4739,6 +5133,7 @@ var Scallop = class {
   API_BASE_URL,
   BORROW_FEE_PROTOCOL_ID,
   PROTOCOL_OBJECT_ID,
+  SDK_API_BASE_URL,
   SUPPORT_BORROW_INCENTIVE_POOLS,
   SUPPORT_BORROW_INCENTIVE_REWARDS,
   SUPPORT_COLLATERALS,
@@ -4751,6 +5146,7 @@ var Scallop = class {
   ScallopAddress,
   ScallopBuilder,
   ScallopClient,
+  ScallopIndexer,
   ScallopQuery,
   ScallopUtils,
   assetCoins,