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

package/dist/index.js

@@ -48,6 +48,7 @@ __export(src_exports, {
   PROTOCOL_OBJECT_ID: () => PROTOCOL_OBJECT_ID,
   PYTH_ENDPOINTS: () => PYTH_ENDPOINTS,
   PYTH_FEED_IDS: () => PYTH_FEED_IDS,
+  RPC_PROVIDERS: () => RPC_PROVIDERS,
   SCA_COIN_TYPE: () => SCA_COIN_TYPE,
   SDK_API_BASE_URL: () => SDK_API_BASE_URL,
   SUPPORT_BORROW_INCENTIVE_POOLS: () => SUPPORT_BORROW_INCENTIVE_POOLS,
@@ -972,6 +973,23 @@ var MAX_LOCK_DURATION = MAX_LOCK_ROUNDS * UNLOCK_ROUND_DURATION;
 var MIN_INITIAL_LOCK_AMOUNT = 1e10;
 var MIN_TOP_UP_AMOUNT = 1e9;
 
+// src/constants/rpc.ts
+var import_client = require("@mysten/sui/client");
+var RPC_PROVIDERS = [
+  (0, import_client.getFullnodeUrl)("mainnet"),
+  "https://sui-mainnet.public.blastapi.io",
+  "https://sui-mainnet-ca-2.cosmostation.io",
+  "https://sui-mainnet-eu-4.cosmostation.io",
+  "https://sui-mainnet-endpoint.blockvision.org",
+  "https://sui-rpc.publicnode.com",
+  "https://sui-mainnet-rpc.allthatnode.com",
+  "https://mainnet.suiet.app",
+  "https://mainnet.sui.rpcpool.com",
+  "https://sui1mainnet-rpc.chainode.tech",
+  "https://fullnode.mainnet.apis.scallop.io",
+  "https://sui-mainnet-us-2.cosmostation.io"
+];
+
 // src/models/scallopAddress.ts
 var import_sui_kit2 = require("@scallop-io/sui-kit");
 
@@ -1082,6 +1100,25 @@ var checkRenewExpiredVeSca = (scaAmount, lockPeriodInDays, prevUnlockAtInMillisT
   }
 };
 
+// src/utils/indexer.ts
+async function callMethodWithIndexerFallback(method, context, ...args) {
+  const indexer = args[args.length - 1];
+  if (indexer) {
+    try {
+      return await method.apply(context, args);
+    } catch (e) {
+      console.warn(`Indexer requests failed: ${e}. Retrying without indexer..`);
+      return await method.apply(context, [...args.slice(0, -1), false]);
+    }
+  }
+  return await method.apply(context, args);
+}
+function withIndexerFallback(method) {
+  return (...args) => {
+    return callMethodWithIndexerFallback(method, this, ...args);
+  };
+}
+
 // src/utils/query.ts
 var import_bignumber = __toESM(require("bignumber.js"));
 var import_utils = require("@mysten/sui/utils");
@@ -1466,6 +1503,66 @@ var estimatedFactor = (amount, scaleStep, type) => {
   return adjustFactor;
 };
 
+// src/utils/tokenBucket.ts
+var TokenBucket = class {
+  constructor(tokensPerInterval, intervalInMs) {
+    this.tokensPerInterval = tokensPerInterval;
+    this.interval = intervalInMs;
+    this.tokens = tokensPerInterval;
+    this.lastRefill = Date.now();
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    if (elapsed > this.interval) {
+      const tokensToAdd = Math.floor(elapsed / this.interval) * this.tokensPerInterval;
+      this.tokens = Math.min(this.tokens + tokensToAdd, this.tokensPerInterval);
+      this.lastRefill = now;
+    }
+  }
+  removeTokens(count) {
+    this.refill();
+    if (this.tokens >= count) {
+      this.tokens -= count;
+      return true;
+    }
+    return false;
+  }
+};
+var callWithRateLimit = async (tokenBucket, fn, retryDelayInMs = DEFAULT_INTERVAL_IN_MS, maxRetries = 30, backoffFactor = 1.25) => {
+  let retries = 0;
+  const tryRequest = async () => {
+    if (tokenBucket.removeTokens(1)) {
+      try {
+        const result = await fn();
+        if (result && result.status === 429) {
+          throw new Error("Unexpected status code: 429");
+        }
+        return result;
+      } catch (error) {
+        if (error.message === "Unexpected status code: 429" && retries < maxRetries) {
+          retries++;
+          const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          return tryRequest();
+        } else {
+          console.error("An error occurred:", error.message);
+          return null;
+        }
+      }
+    } else if (retries < maxRetries) {
+      retries++;
+      const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return tryRequest();
+    } else {
+      console.error("Maximum retries reached");
+      return null;
+    }
+  };
+  return tryRequest();
+};
+
 // src/utils/util.ts
 var COIN_SET = Array.from(
   /* @__PURE__ */ new Set([
@@ -1538,85 +1635,6 @@ var findClosestUnlockRound = (unlockAtInSecondTimestamp) => {
   return Math.floor(closestTwelveAM.getTime() / 1e3);
 };
 
-// src/utils/tokenBucket.ts
-var TokenBucket = class {
-  constructor(tokensPerInterval, intervalInMs) {
-    this.tokensPerInterval = tokensPerInterval;
-    this.interval = intervalInMs;
-    this.tokens = tokensPerInterval;
-    this.lastRefill = Date.now();
-  }
-  refill() {
-    const now = Date.now();
-    const elapsed = now - this.lastRefill;
-    if (elapsed > this.interval) {
-      const tokensToAdd = Math.floor(elapsed / this.interval) * this.tokensPerInterval;
-      this.tokens = Math.min(this.tokens + tokensToAdd, this.tokensPerInterval);
-      this.lastRefill = now;
-    }
-  }
-  removeTokens(count) {
-    this.refill();
-    if (this.tokens >= count) {
-      this.tokens -= count;
-      return true;
-    }
-    return false;
-  }
-};
-var callWithRateLimit = async (tokenBucket, fn, retryDelayInMs = DEFAULT_INTERVAL_IN_MS, maxRetries = 30, backoffFactor = 1.25) => {
-  let retries = 0;
-  const tryRequest = async () => {
-    if (tokenBucket.removeTokens(1)) {
-      try {
-        const result = await fn();
-        if (result && result.status === 429) {
-          throw new Error("Unexpected status code: 429");
-        }
-        return result;
-      } catch (error) {
-        if (error.message === "Unexpected status code: 429" && retries < maxRetries) {
-          retries++;
-          const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          return tryRequest();
-        } else {
-          console.error("An error occurred:", error.message);
-          return null;
-        }
-      }
-    } else if (retries < maxRetries) {
-      retries++;
-      const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      return tryRequest();
-    } else {
-      console.error("Maximum retries reached");
-      return null;
-    }
-  };
-  return tryRequest();
-};
-
-// src/utils/indexer.ts
-async function callMethodWithIndexerFallback(method, context, ...args) {
-  const indexer = args[args.length - 1];
-  if (indexer) {
-    try {
-      return await method.apply(context, args);
-    } catch (e) {
-      console.warn(`Indexer requests failed: ${e}. Retrying without indexer..`);
-      return await method.apply(context, [...args.slice(0, -1), false]);
-    }
-  }
-  return await method.apply(context, args);
-}
-function withIndexerFallback(method) {
-  return (...args) => {
-    return callMethodWithIndexerFallback(method, this, ...args);
-  };
-}
-
 // src/models/scallopCache.ts
 var ScallopCache = class {
   constructor(suiKit, walletAddress, cacheOptions, tokenBucket, queryClient) {
@@ -2457,77 +2475,259 @@ var import_utils25 = require("@mysten/sui/utils");
 var import_utils10 = require("@mysten/sui/utils");
 var import_pyth_sui_js = require("@pythnetwork/pyth-sui-js");
 
-// src/queries/coreQuery.ts
+// src/queries/borrowIncentiveQuery.ts
 var import_utils3 = require("@mysten/sui/utils");
 var import_bignumber2 = __toESM(require("bignumber.js"));
-
-// src/queries/supplyLimit.ts
-var import_zod = require("zod");
-var supplyLimitZod = import_zod.z.object({
-  dataType: import_zod.z.string(),
-  type: import_zod.z.string(),
-  hasPublicTransfer: import_zod.z.boolean(),
-  fields: import_zod.z.object({
-    id: import_zod.z.object({
-      id: import_zod.z.string()
-    }),
-    name: import_zod.z.object({
-      type: import_zod.z.string()
-    }),
-    value: import_zod.z.string()
-  })
-});
-var SUPPLY_LIMIT_KEY = "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::SupplyLimitKey";
-var getSupplyLimit = async (utils, poolName) => {
-  const poolCoinType = utils.parseCoinType(poolName).slice(2);
-  const marketObject = utils.address.get("core.market");
-  if (!marketObject)
-    return null;
-  const object = await utils.cache.queryGetDynamicFieldObject({
-    parentId: marketObject,
-    name: {
-      type: SUPPLY_LIMIT_KEY,
-      value: poolCoinType
-    }
+var queryBorrowIncentivePools = async (address) => {
+  const queryPkgId = address.get("borrowIncentive.query");
+  const incentivePoolsId = address.get("borrowIncentive.incentivePools");
+  const queryTarget = `${queryPkgId}::incentive_pools_query::incentive_pools_data`;
+  const args = [incentivePoolsId];
+  const queryResult = await address.cache.queryInspectTxn({
+    queryTarget,
+    args
   });
-  const parsedData = supplyLimitZod.safeParse(object?.data?.content);
-  if (!parsedData.success)
-    return null;
-  return parsedData.data.fields.value;
+  const borrowIncentivePoolsQueryData = queryResult?.events[0].parsedJson;
+  return borrowIncentivePoolsQueryData;
 };
-
-// src/queries/coreQuery.ts
-var queryMarket = async (query, indexer = false, coinPrices) => {
+var getBorrowIncentivePools = async (query, borrowIncentiveCoinNames = [
+  ...SUPPORT_BORROW_INCENTIVE_POOLS
+], indexer = false, coinPrices) => {
+  const borrowIncentivePools = {};
   coinPrices = coinPrices ?? await query.utils.getCoinPrices() ?? {};
-  const pools = {};
-  const collaterals = {};
   if (indexer) {
-    const marketIndexer = await query.indexer.getMarket();
-    const updatePools = (item) => {
-      item.coinPrice = coinPrices[item.coinName] ?? item.coinPrice;
-      item.coinWrappedType = query.utils.getCoinWrappedType(item.coinName);
-      pools[item.coinName] = item;
-    };
-    const updateCollaterals = (item) => {
-      item.coinPrice = coinPrices[item.coinName] ?? item.coinPrice;
-      item.coinWrappedType = query.utils.getCoinWrappedType(item.coinName);
-      collaterals[item.coinName] = item;
-    };
-    Object.values(marketIndexer.pools).forEach(updatePools);
-    Object.values(marketIndexer.collaterals).forEach(updateCollaterals);
-    return {
-      pools,
-      collaterals
+    const borrowIncentivePoolsIndexer = await query.indexer.getBorrowIncentivePools();
+    const updateBorrowIncentivePool = (pool) => {
+      if (!borrowIncentiveCoinNames.includes(pool.coinName))
+        return;
+      pool.coinPrice = coinPrices[pool.coinName] ?? pool.coinPrice;
+      borrowIncentivePools[pool.coinName] = pool;
     };
+    Object.values(borrowIncentivePoolsIndexer).forEach(
+      updateBorrowIncentivePool
+    );
+    return borrowIncentivePools;
   }
-  const packageId = query.address.get("core.packages.query.id");
-  const marketId = query.address.get("core.market");
+  const borrowIncentivePoolsQueryData = await queryBorrowIncentivePools(
+    query.address
+  );
+  for (const pool of borrowIncentivePoolsQueryData?.incentive_pools ?? []) {
+    const borrowIncentivePoolPoints = {};
+    const parsedBorrowIncentivePoolData = parseOriginBorrowIncentivePoolData(pool);
+    const poolCoinType = (0, import_utils3.normalizeStructTag)(pool.pool_type.name);
+    const poolCoinName = query.utils.parseCoinNameFromType(
+      poolCoinType
+    );
+    const poolCoinPrice = coinPrices?.[poolCoinName] ?? 0;
+    const poolCoinDecimal = query.utils.getCoinDecimal(poolCoinName);
+    if (!borrowIncentiveCoinNames.includes(poolCoinName)) {
+      continue;
+    }
+    for (const [coinName, poolPoint] of Object.entries(
+      parsedBorrowIncentivePoolData.poolPoints
+    )) {
+      const rewardCoinType = (0, import_utils3.normalizeStructTag)(poolPoint.pointType);
+      const rewardCoinName = query.utils.parseCoinNameFromType(
+        rewardCoinType
+      );
+      const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+      const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+      const symbol = query.utils.parseSymbol(rewardCoinName);
+      const coinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+      const calculatedPoolPoint = calculateBorrowIncentivePoolPointData(
+        // parsedBorrowIncentivePoolData,
+        poolPoint,
+        rewardCoinPrice,
+        rewardCoinDecimal,
+        poolCoinPrice,
+        poolCoinDecimal
+      );
+      borrowIncentivePoolPoints[coinName] = {
+        symbol,
+        coinName: rewardCoinName,
+        coinType: rewardCoinType,
+        coinDecimal,
+        coinPrice: rewardCoinPrice,
+        points: poolPoint.points,
+        distributedPoint: poolPoint.distributedPoint,
+        weightedAmount: poolPoint.weightedAmount,
+        ...calculatedPoolPoint
+      };
+    }
+    const stakedAmount = (0, import_bignumber2.default)(parsedBorrowIncentivePoolData.staked);
+    const stakedCoin = stakedAmount.shiftedBy(-1 * poolCoinDecimal);
+    const stakedValue = stakedCoin.multipliedBy(poolCoinPrice);
+    borrowIncentivePools[poolCoinName] = {
+      coinName: poolCoinName,
+      symbol: query.utils.parseSymbol(poolCoinName),
+      coinType: poolCoinType,
+      coinDecimal: poolCoinDecimal,
+      coinPrice: poolCoinPrice,
+      stakedAmount: stakedAmount.toNumber(),
+      stakedCoin: stakedCoin.toNumber(),
+      stakedValue: stakedValue.toNumber(),
+      points: borrowIncentivePoolPoints
+    };
+  }
+  return borrowIncentivePools;
+};
+var queryBorrowIncentiveAccounts = async ({
+  utils
+}, obligationId, borrowIncentiveCoinNames = [
+  ...SUPPORT_BORROW_INCENTIVE_POOLS
+]) => {
+  const queryPkgId = utils.address.get("borrowIncentive.query");
+  const incentiveAccountsId = utils.address.get(
+    "borrowIncentive.incentiveAccounts"
+  );
+  const queryTarget = `${queryPkgId}::incentive_account_query::incentive_account_data`;
+  const args = [incentiveAccountsId, obligationId];
+  const queryResult = await utils.cache.queryInspectTxn({ queryTarget, args });
+  const borrowIncentiveAccountsQueryData = queryResult?.events[0]?.parsedJson;
+  const borrowIncentiveAccounts = Object.values(
+    borrowIncentiveAccountsQueryData?.pool_records ?? []
+  ).reduce((accounts, accountData) => {
+    const parsedBorrowIncentiveAccount = parseOriginBorrowIncentiveAccountData(accountData);
+    const poolType = parsedBorrowIncentiveAccount.poolType;
+    const coinName = utils.parseCoinNameFromType(poolType);
+    if (borrowIncentiveCoinNames && borrowIncentiveCoinNames.includes(coinName)) {
+      accounts[coinName] = parsedBorrowIncentiveAccount;
+    }
+    return accounts;
+  }, {});
+  return borrowIncentiveAccounts;
+};
+var getBindedObligationId = async ({
+  address
+}, veScaKeyId) => {
+  const borrowIncentiveObjectId = address.get("borrowIncentive.object");
+  const incentivePoolsId = address.get("borrowIncentive.incentivePools");
+  const veScaObjId = address.get("vesca.object");
+  const incentivePoolsResponse = await address.cache.queryGetObject(
+    incentivePoolsId,
+    {
+      showContent: true
+    }
+  );
+  if (incentivePoolsResponse?.data?.content?.dataType !== "moveObject")
+    return null;
+  const incentivePoolFields = incentivePoolsResponse.data.content.fields;
+  const veScaBindTableId = incentivePoolFields.ve_sca_bind.fields.id.id;
+  const keyType = `${borrowIncentiveObjectId}::typed_id::TypedID<${veScaObjId}::ve_sca::VeScaKey>`;
+  const veScaBindTableResponse = await address.cache.queryGetDynamicFieldObject(
+    {
+      parentId: veScaBindTableId,
+      name: {
+        type: keyType,
+        value: veScaKeyId
+      }
+    }
+  );
+  if (veScaBindTableResponse?.data?.content?.dataType !== "moveObject")
+    return null;
+  const veScaBindTableFields = veScaBindTableResponse.data.content.fields;
+  const obligationId = veScaBindTableFields.value.fields.id;
+  return obligationId;
+};
+var getBindedVeScaKey = async ({
+  address
+}, obligationId) => {
+  const borrowIncentiveObjectId = address.get("borrowIncentive.object");
+  const incentiveAccountsId = address.get("borrowIncentive.incentiveAccounts");
+  const corePkg = address.get("core.object");
+  const incentiveAccountsObject = await address.cache.queryGetObject(
+    incentiveAccountsId,
+    {
+      showContent: true
+    }
+  );
+  if (incentiveAccountsObject?.data?.content?.dataType !== "moveObject")
+    return null;
+  const incentiveAccountsTableId = incentiveAccountsObject.data.content.fields.accounts.fields.id.id;
+  const bindedIncentiveAcc = await address.cache.queryGetDynamicFieldObject({
+    parentId: incentiveAccountsTableId,
+    name: {
+      type: `${borrowIncentiveObjectId}::typed_id::TypedID<${corePkg}::obligation::Obligation>`,
+      value: obligationId
+    }
+  });
+  if (bindedIncentiveAcc?.data?.content?.dataType !== "moveObject")
+    return null;
+  const bindedIncentiveAccFields = bindedIncentiveAcc.data.content.fields;
+  return bindedIncentiveAccFields.value.fields.binded_ve_sca_key?.fields.id ?? null;
+};
+
+// src/queries/coreQuery.ts
+var import_utils5 = require("@mysten/sui/utils");
+var import_bignumber3 = __toESM(require("bignumber.js"));
+
+// src/queries/supplyLimitQuery.ts
+var import_zod = require("zod");
+var supplyLimitZod = import_zod.z.object({
+  dataType: import_zod.z.string(),
+  type: import_zod.z.string(),
+  hasPublicTransfer: import_zod.z.boolean(),
+  fields: import_zod.z.object({
+    id: import_zod.z.object({
+      id: import_zod.z.string()
+    }),
+    name: import_zod.z.object({
+      type: import_zod.z.string()
+    }),
+    value: import_zod.z.string()
+  })
+});
+var SUPPLY_LIMIT_KEY = "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::SupplyLimitKey";
+var getSupplyLimit = async (utils, poolName) => {
+  const poolCoinType = utils.parseCoinType(poolName).slice(2);
+  const marketObject = utils.address.get("core.market");
+  if (!marketObject)
+    return null;
+  const object = await utils.cache.queryGetDynamicFieldObject({
+    parentId: marketObject,
+    name: {
+      type: SUPPLY_LIMIT_KEY,
+      value: poolCoinType
+    }
+  });
+  const parsedData = supplyLimitZod.safeParse(object?.data?.content);
+  if (!parsedData.success)
+    return null;
+  return parsedData.data.fields.value;
+};
+
+// src/queries/coreQuery.ts
+var queryMarket = async (query, indexer = false, coinPrices) => {
+  coinPrices = coinPrices ?? await query.utils.getCoinPrices() ?? {};
+  const pools = {};
+  const collaterals = {};
+  if (indexer) {
+    const marketIndexer = await query.indexer.getMarket();
+    const updatePools = (item) => {
+      item.coinPrice = coinPrices[item.coinName] ?? item.coinPrice;
+      item.coinWrappedType = query.utils.getCoinWrappedType(item.coinName);
+      pools[item.coinName] = item;
+    };
+    const updateCollaterals = (item) => {
+      item.coinPrice = coinPrices[item.coinName] ?? item.coinPrice;
+      item.coinWrappedType = query.utils.getCoinWrappedType(item.coinName);
+      collaterals[item.coinName] = item;
+    };
+    Object.values(marketIndexer.pools).forEach(updatePools);
+    Object.values(marketIndexer.collaterals).forEach(updateCollaterals);
+    return {
+      pools,
+      collaterals
+    };
+  }
+  const packageId = query.address.get("core.packages.query.id");
+  const marketId = query.address.get("core.market");
   const queryTarget = `${packageId}::market_query::market_data`;
   const args = [marketId];
   const queryResult = await query.cache.queryInspectTxn({ queryTarget, args });
   const marketData = queryResult?.events[0]?.parsedJson;
   for (const pool of marketData?.pools ?? []) {
-    const coinType = (0, import_utils3.normalizeStructTag)(pool.type.name);
+    const coinType = (0, import_utils5.normalizeStructTag)(pool.type.name);
     const poolCoinName = query.utils.parseCoinNameFromType(coinType);
     const coinPrice = coinPrices[poolCoinName] ?? 0;
     if (!SUPPORT_POOLS.includes(poolCoinName)) {
@@ -2559,7 +2759,7 @@ var queryMarket = async (query, indexer = false, coinPrices) => {
       parsedMarketPoolData
     );
     const coinDecimal = query.utils.getCoinDecimal(poolCoinName);
-    const maxSupplyCoin = (0, import_bignumber2.default)(
+    const maxSupplyCoin = (0, import_bignumber3.default)(
       await getSupplyLimit(query.utils, poolCoinName) ?? "0"
     ).shiftedBy(-coinDecimal).toNumber();
     pools[poolCoinName] = {
@@ -2587,7 +2787,7 @@ var queryMarket = async (query, indexer = false, coinPrices) => {
     };
   }
   for (const collateral of marketData?.collaterals ?? []) {
-    const coinType = (0, import_utils3.normalizeStructTag)(collateral.type.name);
+    const coinType = (0, import_utils5.normalizeStructTag)(collateral.type.name);
     const collateralCoinName = query.utils.parseCoinNameFromType(coinType);
     const coinPrice = coinPrices[collateralCoinName] ?? 0;
     if (!SUPPORT_COLLATERALS.includes(collateralCoinName)) {
@@ -2795,7 +2995,7 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
       parsedMarketPoolData
     );
     const coinDecimal = query.utils.getCoinDecimal(poolCoinName);
-    const maxSupplyCoin = (0, import_bignumber2.default)(
+    const maxSupplyCoin = (0, import_bignumber3.default)(
       await getSupplyLimit(query.utils, poolCoinName) ?? "0"
     ).shiftedBy(-coinDecimal).toNumber();
     marketPool = {
@@ -3039,7 +3239,7 @@ var getCoinAmount = async (query, assetCoinName, ownerAddress) => {
     owner,
     coinType
   });
-  return (0, import_bignumber2.default)(amount).toNumber();
+  return (0, import_bignumber3.default)(amount).toNumber();
 };
 var getMarketCoinAmounts = async (query, marketCoinNames, ownerAddress) => {
   marketCoinNames = marketCoinNames || [...SUPPORT_POOLS].map(
@@ -3066,7 +3266,7 @@ var getMarketCoinAmount = async (query, marketCoinName, ownerAddress) => {
     owner,
     coinType: marketCoinType
   });
-  return (0, import_bignumber2.default)(amount).toNumber();
+  return (0, import_bignumber3.default)(amount).toNumber();
 };
 var getFlashLoanFees = async (query, assetNames) => {
   const FEE_RATE = 1e4;
@@ -3127,1124 +3327,1182 @@ var getFlashLoanFees = async (query, assetNames) => {
   );
 };
 
-// src/queries/spoolQuery.ts
-var import_utils5 = require("@mysten/sui/utils");
-var getSpools = async (query, stakeMarketCoinNames = [...SUPPORT_SPOOLS], indexer = false, marketPools, coinPrices) => {
-  const stakeCoinNames = stakeMarketCoinNames.map(
-    (stakeMarketCoinName) => query.utils.parseCoinName(stakeMarketCoinName)
-  );
-  coinPrices = coinPrices ?? await query.utils.getCoinPrices() ?? {};
-  marketPools = marketPools ?? await query.getMarketPools(stakeCoinNames, indexer);
-  if (!marketPools)
-    throw new Error(`Fail to fetch marketPools for ${stakeCoinNames}`);
-  const spools = {};
-  if (indexer) {
-    const spoolsIndexer = await query.indexer.getSpools();
-    const updateSpools = (spool) => {
-      if (!stakeMarketCoinNames.includes(spool.marketCoinName))
-        return;
-      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] ? (coinPrices[coinName] ?? 0) * (marketPool ? marketPool.conversionRate : 0) : spool.marketCoinPrice;
-      spool.rewardCoinPrice = coinPrices[rewardCoinName] ?? spool.rewardCoinPrice;
-      spools[spool.marketCoinName] = spool;
+// src/queries/isolatedAssetQuery.ts
+var import_zod2 = require("zod");
+var isolatedAssetZod = import_zod2.z.object({
+  dataType: import_zod2.z.string(),
+  type: import_zod2.z.string(),
+  hasPublicTransfer: import_zod2.z.boolean(),
+  fields: import_zod2.z.object({
+    id: import_zod2.z.object({
+      id: import_zod2.z.string()
+    }),
+    name: import_zod2.z.object({
+      type: import_zod2.z.string()
+    }),
+    value: import_zod2.z.boolean()
+  })
+});
+var ISOLATED_ASSET_KEY = "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::IsolatedAssetKey";
+var getIsolatedAssets = async (address) => {
+  try {
+    const marketObject = address.get("core.market");
+    const isolatedAssets = [];
+    if (!marketObject)
+      return isolatedAssets;
+    let hasNextPage = false;
+    let nextCursor = null;
+    const isIsolatedDynamicField = (dynamicField) => {
+      return dynamicField.name.type === ISOLATED_ASSET_KEY;
     };
-    Object.values(spoolsIndexer).forEach(updateSpools);
-    return spools;
-  }
-  for (const stakeMarketCoinName of stakeMarketCoinNames) {
-    const stakeCoinName = query.utils.parseCoinName(stakeMarketCoinName);
-    const spool = await getSpool(
-      query,
-      stakeMarketCoinName,
-      indexer,
-      marketPools[stakeCoinName],
-      coinPrices
-    );
-    if (spool) {
-      spools[stakeMarketCoinName] = spool;
-    }
+    do {
+      const response = await address.cache.queryGetDynamicFields({
+        parentId: marketObject,
+        cursor: nextCursor,
+        limit: 10
+      });
+      if (!response)
+        break;
+      const isolatedAssetCoinTypes = response.data.filter(isIsolatedDynamicField).map(({ name }) => `0x${name.value.type.name}`);
+      isolatedAssets.push(...isolatedAssetCoinTypes);
+      if (response && response.hasNextPage && response.nextCursor) {
+        hasNextPage = true;
+        nextCursor = response.nextCursor;
+      } else {
+        hasNextPage = false;
+      }
+    } while (hasNextPage);
+    return isolatedAssets;
+  } catch (e) {
+    console.error(e);
+    return [];
   }
-  return spools;
 };
-var getSpool = async (query, marketCoinName, indexer = false, marketPool, coinPrices) => {
-  const coinName = query.utils.parseCoinName(marketCoinName);
-  marketPool = marketPool || await query.getMarketPool(coinName, indexer);
-  if (!marketPool) {
-    throw new Error(`Fail to fetch marketPool for ${coinName}`);
-  }
-  const poolId = query.address.get(`spool.pools.${marketCoinName}.id`);
-  const rewardPoolId = query.address.get(
-    `spool.pools.${marketCoinName}.rewardPoolId`
-  );
-  let spool = void 0;
-  coinPrices = coinPrices || await query.utils.getCoinPrices([coinName]);
-  if (indexer) {
-    const spoolIndexer = await query.indexer.getSpool(marketCoinName);
-    const coinName2 = query.utils.parseCoinName(marketCoinName);
-    const rewardCoinName2 = query.utils.getSpoolRewardCoinName(marketCoinName);
-    spoolIndexer.coinPrice = coinPrices?.[coinName2] || spoolIndexer.coinPrice;
-    spoolIndexer.marketCoinPrice = (coinPrices?.[coinName2] ?? 0) * (marketPool ? marketPool.conversionRate : 0) || spoolIndexer.marketCoinPrice;
-    spoolIndexer.rewardCoinPrice = coinPrices?.[rewardCoinName2] || spoolIndexer.rewardCoinPrice;
-    return spoolIndexer;
-  }
-  const spoolObjectResponse = await query.cache.queryGetObjects(
-    [poolId, rewardPoolId],
-    {
-      showContent: true
+var isIsolatedAsset = async (utils, coinName) => {
+  try {
+    const marketObject = utils.address.get("core.market");
+    const cachedData = utils.address.cache.queryClient.getQueryData([
+      "getDynamicFields",
+      marketObject
+    ]);
+    if (cachedData) {
+      const coinType2 = utils.parseCoinType(coinName);
+      return cachedData.includes(coinType2);
     }
-  );
-  if (!(spoolObjectResponse[0] && spoolObjectResponse[1])) {
-    throw new Error("Fail to fetch spoolObjectResponse!");
-  }
-  const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
-  coinPrices = coinPrices || await query.utils.getCoinPrices([coinName, rewardCoinName]);
-  const spoolObject = spoolObjectResponse[0];
-  const rewardPoolObject = spoolObjectResponse[1];
-  if (spoolObject.content && "fields" in spoolObject.content) {
-    const spoolFields = spoolObject.content.fields;
-    const parsedSpoolData = parseOriginSpoolData({
-      stakeType: spoolFields.stake_type,
-      maxDistributedPoint: spoolFields.max_distributed_point,
-      distributedPoint: spoolFields.distributed_point,
-      distributedPointPerPeriod: spoolFields.distributed_point_per_period,
-      pointDistributionTime: spoolFields.point_distribution_time,
-      maxStake: spoolFields.max_stakes,
-      stakes: spoolFields.stakes,
-      index: spoolFields.index,
-      createdAt: spoolFields.created_at,
-      lastUpdate: spoolFields.last_update
+    const coinType = utils.parseCoinType(coinName).slice(2);
+    const object = await utils.cache.queryGetDynamicFieldObject({
+      parentId: marketObject,
+      name: {
+        type: ISOLATED_ASSET_KEY,
+        value: coinType
+      }
     });
-    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 rewardPoolFields = rewardPoolObject.content.fields;
-      const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData({
-        claimed_rewards: rewardPoolFields.claimed_rewards,
-        exchange_rate_numerator: rewardPoolFields.exchange_rate_numerator,
-        exchange_rate_denominator: rewardPoolFields.exchange_rate_denominator,
-        rewards: rewardPoolFields.rewards,
-        spool_id: rewardPoolFields.spool_id
-      });
-      const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
-      const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
-      const calculatedRewardPoolData = calculateSpoolRewardPoolData(
-        parsedSpoolData,
-        parsedSpoolRewardPoolData,
-        calculatedSpoolData,
-        rewardCoinPrice,
-        rewardCoinDecimal
-      );
-      spool = {
-        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),
-        sCoinType: marketPool.sCoinType,
-        coinDecimal: query.utils.getCoinDecimal(coinName),
-        rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoinName),
-        coinPrice: coinPrices?.[coinName] ?? 0,
-        marketCoinPrice,
-        rewardCoinPrice,
-        maxPoint: parsedSpoolData.maxPoint,
-        distributedPoint: parsedSpoolData.distributedPoint,
-        maxStake: parsedSpoolData.maxStake,
-        ...calculatedSpoolData,
-        exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
-        exchangeRateDenominator: parsedSpoolRewardPoolData.exchangeRateDenominator,
-        ...calculatedRewardPoolData
-      };
-    }
+    const parsedData = isolatedAssetZod.safeParse(object?.data?.content);
+    if (!parsedData.success)
+      return false;
+    return parsedData.data.fields.value;
+  } catch (e) {
+    console.error(e);
+    return false;
   }
-  return spool;
 };
-var getStakeAccounts = async ({
-  utils
-}, ownerAddress) => {
-  const owner = ownerAddress || utils.suiKit.currentAddress();
-  const spoolObjectId = utils.address.get("spool.object");
-  const stakeAccountType = `${spoolObjectId}::spool_account::SpoolAccount`;
-  const stakeObjectsResponse = [];
-  let hasNextPage = false;
-  let nextCursor = null;
-  do {
-    const paginatedStakeObjectsResponse = await utils.cache.queryGetOwnedObjects({
-      owner,
-      filter: { StructType: stakeAccountType },
-      options: {
-        showContent: true,
-        showType: true
-      },
-      cursor: nextCursor,
-      limit: 10
-    });
-    if (!paginatedStakeObjectsResponse)
-      continue;
-    stakeObjectsResponse.push(...paginatedStakeObjectsResponse.data);
-    if (paginatedStakeObjectsResponse.hasNextPage && paginatedStakeObjectsResponse.nextCursor) {
-      hasNextPage = true;
-      nextCursor = paginatedStakeObjectsResponse.nextCursor;
-    } else {
-      hasNextPage = false;
+
+// src/queries/loyaltyProgramQuery.ts
+var import_bignumber4 = __toESM(require("bignumber.js"));
+var import_zod3 = require("zod");
+var rewardPoolFieldsZod = import_zod3.z.object({
+  balance: import_zod3.z.string(),
+  enable_claim: import_zod3.z.boolean()
+}).transform((value) => ({
+  totalPoolReward: (0, import_bignumber4.default)(value.balance).shiftedBy(-9).toNumber(),
+  isClaimEnabled: value.enable_claim
+}));
+var userRewardFieldsZod = import_zod3.z.object({
+  value: import_zod3.z.string()
+}).transform((value) => (0, import_bignumber4.default)(value.value).shiftedBy(-9).toNumber());
+var getLoyaltyProgramInformations = async (query, veScaKey) => {
+  const rewardPool = query.address.get("loyaltyProgram.rewardPool");
+  const rewardPoolObject = await query.cache.queryGetObject(rewardPool, {
+    showContent: true
+  });
+  if (rewardPoolObject?.data?.content?.dataType !== "moveObject")
+    return null;
+  const rewardPoolFields = rewardPoolObject.data.content.fields;
+  const { isClaimEnabled, totalPoolReward } = rewardPoolFieldsZod.parse(
+    rewardPoolFields
+  );
+  const result = {
+    pendingReward: 0,
+    totalPoolReward,
+    isClaimEnabled
+  };
+  veScaKey = veScaKey ?? (await query.getVeScas())[0]?.keyObject;
+  if (!veScaKey)
+    return result;
+  const userRewardTableId = query.address.get(
+    "loyaltyProgram.userRewardTableId"
+  );
+  const userRewardObject = await query.cache.queryGetDynamicFieldObject({
+    parentId: userRewardTableId,
+    name: {
+      type: "0x2::object::ID",
+      value: typeof veScaKey === "string" ? veScaKey : veScaKey.objectId
     }
-  } while (hasNextPage);
-  const stakeAccounts = SUPPORT_SPOOLS.reduce(
-    (acc, stakeName) => {
-      acc[stakeName] = [];
-      return acc;
-    },
-    {}
+  });
+  if (userRewardObject?.data?.content?.dataType !== "moveObject")
+    return result;
+  const userRewardFields = userRewardObject.data.content.fields;
+  result.pendingReward = userRewardFieldsZod.parse(
+    userRewardFields
   );
-  const stakeMarketCoinTypes = Object.keys(stakeAccounts).reduce(
-    (types, stakeMarketCoinName) => {
-      const stakeCoinName = utils.parseCoinName(stakeMarketCoinName);
-      const marketCoinType = utils.parseMarketCoinType(stakeCoinName);
-      types[stakeMarketCoinName] = `${spoolObjectId}::spool_account::SpoolAccount<${marketCoinType}>`;
-      return types;
-    },
-    {}
+  return result;
+};
+
+// src/queries/portfolioQuery.ts
+var import_bignumber5 = __toESM(require("bignumber.js"));
+var getLendings = async (query, poolCoinNames = [...SUPPORT_POOLS], ownerAddress, indexer = false) => {
+  const marketCoinNames = poolCoinNames.map(
+    (poolCoinName) => query.utils.parseMarketCoinName(poolCoinName)
   );
-  const reversedStakeMarketCoinTypes = Object.entries(stakeMarketCoinTypes).reduce(
-    (reversedTypes, [key, value]) => {
-      reversedTypes[value] = key;
-      return reversedTypes;
-    },
-    {}
+  const stakeMarketCoinNames = marketCoinNames.filter(
+    (marketCoinName) => SUPPORT_SPOOLS.includes(marketCoinName)
   );
-  for (const stakeObject of stakeObjectsResponse.map((ref) => ref.data)) {
-    const id = stakeObject?.objectId;
-    const type = stakeObject?.type;
-    if (id && stakeObject?.content && "fields" in stakeObject.content) {
-      const fields = stakeObject.content.fields;
-      const stakePoolId = String(fields.spool_id);
-      const stakeType = String(fields.stake_type.fields.name);
-      const staked = Number(fields.stakes);
-      const index = Number(fields.index);
-      const points = Number(fields.points);
-      const totalPoints = Number(fields.total_points);
-      const stakeMarketCoinTypeMap = {
-        sweth: stakeAccounts.sweth,
-        ssui: stakeAccounts.ssui,
-        swusdc: stakeAccounts.swusdc,
-        swusdt: stakeAccounts.swusdt,
-        scetus: stakeAccounts.scetus,
-        safsui: stakeAccounts.safsui,
-        shasui: stakeAccounts.shasui,
-        svsui: stakeAccounts.svsui,
-        susdc: stakeAccounts.susdc
-      };
-      const normalizedType = (0, import_utils5.normalizeStructTag)(type);
-      const stakeAccountArray = stakeMarketCoinTypeMap[reversedStakeMarketCoinTypes[normalizedType]];
-      if (stakeAccountArray) {
-        stakeAccountArray.push({
-          id,
-          type: normalizedType,
-          stakePoolId,
-          stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
-          staked,
-          index,
-          points,
-          totalPoints
-        });
-      }
-    }
-  }
-  return stakeAccounts;
-};
-var getStakePool = async ({
-  utils
-}, marketCoinName) => {
-  const poolId = utils.address.get(`spool.pools.${marketCoinName}.id`);
-  let stakePool = void 0;
-  const stakePoolObjectResponse = await utils.cache.queryGetObject(poolId, {
-    showContent: true,
-    showType: true
+  const coinPrices = await query.utils.getCoinPrices(poolCoinNames);
+  const marketPools = await query.getMarketPools(poolCoinNames, indexer, {
+    coinPrices
   });
-  if (stakePoolObjectResponse?.data) {
-    const stakePoolObject = stakePoolObjectResponse.data;
-    const id = stakePoolObject.objectId;
-    const type = stakePoolObject.type;
-    if (stakePoolObject.content && "fields" in stakePoolObject.content) {
-      const fields = stakePoolObject.content.fields;
-      const maxPoint = Number(fields.max_distributed_point);
-      const distributedPoint = Number(fields.distributed_point);
-      const pointPerPeriod = Number(fields.distributed_point_per_period);
-      const period = Number(fields.point_distribution_time);
-      const maxStake = Number(fields.max_stakes);
-      const stakeType = String(fields.stake_type.fields.name);
-      const totalStaked = Number(fields.stakes);
-      const index = Number(fields.index);
-      const createdAt = Number(fields.created_at);
-      const lastUpdate = Number(fields.last_update);
-      stakePool = {
-        id,
-        type: (0, import_utils5.normalizeStructTag)(type),
-        maxPoint,
-        distributedPoint,
-        pointPerPeriod,
-        period,
-        maxStake,
-        stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
-        totalStaked,
-        index,
-        createdAt,
-        lastUpdate
-      };
-    }
-  }
-  return stakePool;
-};
-var getStakeRewardPool = async ({
-  utils
-}, marketCoinName) => {
-  const poolId = utils.address.get(
-    `spool.pools.${marketCoinName}.rewardPoolId`
+  const spools = await query.getSpools(stakeMarketCoinNames, indexer, {
+    marketPools,
+    coinPrices
+  });
+  const [coinAmounts, marketCoinAmounts, allStakeAccounts] = await Promise.all([
+    query.getCoinAmounts(poolCoinNames, ownerAddress),
+    query.getMarketCoinAmounts(marketCoinNames, ownerAddress),
+    query.getAllStakeAccounts(ownerAddress)
+  ]);
+  const lendings = {};
+  await Promise.allSettled(
+    poolCoinNames.map(async (poolCoinName) => {
+      const stakeMarketCoinName = stakeMarketCoinNames.find(
+        (marketCoinName2) => marketCoinName2 === query.utils.parseMarketCoinName(poolCoinName)
+      );
+      const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
+      lendings[poolCoinName] = await getLending(
+        query,
+        poolCoinName,
+        ownerAddress,
+        indexer,
+        marketPools?.[poolCoinName],
+        stakeMarketCoinName ? spools[stakeMarketCoinName] : void 0,
+        stakeMarketCoinName ? allStakeAccounts[stakeMarketCoinName] : [],
+        coinAmounts?.[poolCoinName],
+        marketCoinAmounts?.[marketCoinName],
+        coinPrices?.[poolCoinName] ?? 0
+      );
+    })
   );
-  let stakeRewardPool = void 0;
-  const stakeRewardPoolObjectResponse = await utils.cache.queryGetObject(
-    poolId,
+  return lendings;
+};
+var getLending = async (query, poolCoinName, ownerAddress, indexer = false, marketPool, spool, stakeAccounts, coinAmount, marketCoinAmount, coinPrice, sCoinAmount) => {
+  const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
+  coinPrice = coinPrice ?? (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ?? 0;
+  marketPool = marketPool ?? await query.getMarketPool(poolCoinName, indexer, {
+    coinPrice
+  });
+  if (!marketPool)
+    throw new Error(`Failed to fetch marketPool for ${poolCoinName}`);
+  spool = spool ?? SUPPORT_SPOOLS.includes(marketCoinName) ? await query.getSpool(
+    marketCoinName,
+    indexer,
     {
-      showContent: true,
-      showType: true
+      marketPool,
+      coinPrices: {
+        [poolCoinName]: coinPrice
+      }
     }
-  );
-  if (stakeRewardPoolObjectResponse?.data) {
-    const stakeRewardPoolObject = stakeRewardPoolObjectResponse.data;
-    const id = stakeRewardPoolObject.objectId;
-    const type = stakeRewardPoolObject.type;
-    if (stakeRewardPoolObject.content && "fields" in stakeRewardPoolObject.content) {
-      const rewardPoolFields = stakeRewardPoolObject.content.fields;
-      const stakePoolId = String(rewardPoolFields.spool_id);
-      const ratioNumerator = Number(rewardPoolFields.exchange_rate_numerator);
-      const ratioDenominator = Number(
-        rewardPoolFields.exchange_rate_denominator
+  ) : void 0;
+  stakeAccounts = stakeAccounts || SUPPORT_SPOOLS.includes(marketCoinName) ? await query.getStakeAccounts(
+    marketCoinName,
+    ownerAddress
+  ) : [];
+  coinAmount = coinAmount || await query.getCoinAmount(poolCoinName, ownerAddress);
+  marketCoinAmount = marketCoinAmount || await query.getMarketCoinAmount(marketCoinName, ownerAddress);
+  sCoinAmount = sCoinAmount || await query.getSCoinAmount(marketCoinName, ownerAddress);
+  const coinDecimal = query.utils.getCoinDecimal(poolCoinName);
+  let stakedMarketAmount = (0, import_bignumber5.default)(0);
+  let stakedMarketCoin = (0, import_bignumber5.default)(0);
+  let stakedAmount = (0, import_bignumber5.default)(0);
+  let stakedCoin = (0, import_bignumber5.default)(0);
+  let stakedValue = (0, import_bignumber5.default)(0);
+  let availableUnstakeAmount = (0, import_bignumber5.default)(0);
+  let availableUnstakeCoin = (0, import_bignumber5.default)(0);
+  let availableClaimAmount = (0, import_bignumber5.default)(0);
+  let availableClaimCoin = (0, import_bignumber5.default)(0);
+  if (spool) {
+    for (const stakeAccount of stakeAccounts) {
+      const accountStakedMarketCoinAmount = (0, import_bignumber5.default)(stakeAccount.staked);
+      const accountStakedMarketCoin = accountStakedMarketCoinAmount.shiftedBy(
+        -1 * spool.coinDecimal
+      );
+      const accountStakedAmount = accountStakedMarketCoinAmount.multipliedBy(
+        marketPool?.conversionRate ?? 1
+      );
+      const accountStakedCoin = accountStakedAmount.shiftedBy(
+        -1 * spool.coinDecimal
+      );
+      const accountStakedValue = accountStakedCoin.multipliedBy(
+        spool.coinPrice
+      );
+      stakedMarketAmount = stakedMarketAmount.plus(
+        accountStakedMarketCoinAmount
+      );
+      stakedMarketCoin = stakedMarketCoin.plus(accountStakedMarketCoin);
+      stakedAmount = stakedAmount.plus(accountStakedAmount);
+      stakedCoin = stakedCoin.plus(accountStakedCoin);
+      stakedValue = stakedValue.plus(accountStakedValue);
+      availableUnstakeAmount = availableUnstakeAmount.plus(
+        accountStakedMarketCoinAmount
+      );
+      availableUnstakeCoin = availableUnstakeAmount.shiftedBy(
+        -1 * spool.coinDecimal
+      );
+      const baseIndexRate = 1e9;
+      const increasedPointRate = spool.currentPointIndex ? (0, import_bignumber5.default)(spool.currentPointIndex - stakeAccount.index).dividedBy(
+        baseIndexRate
+      ) : 1;
+      availableClaimAmount = availableClaimAmount.plus(
+        accountStakedMarketCoinAmount.multipliedBy(increasedPointRate).plus(stakeAccount.points).multipliedBy(spool.exchangeRateNumerator).dividedBy(spool.exchangeRateDenominator)
+      );
+      availableClaimCoin = availableClaimAmount.shiftedBy(
+        -1 * spool.rewardCoinDecimal
       );
-      const rewards = Number(rewardPoolFields.rewards);
-      const claimedRewards = Number(rewardPoolFields.claimed_rewards);
-      stakeRewardPool = {
-        id,
-        type: (0, import_utils5.normalizeStructTag)(type),
-        stakePoolId,
-        ratioNumerator,
-        ratioDenominator,
-        rewards,
-        claimedRewards
-      };
     }
   }
-  return stakeRewardPool;
-};
-
-// src/queries/borrowIncentiveQuery.ts
-var import_utils7 = require("@mysten/sui/utils");
-var import_bignumber3 = __toESM(require("bignumber.js"));
-var queryBorrowIncentivePools = async (address) => {
-  const queryPkgId = address.get("borrowIncentive.query");
-  const incentivePoolsId = address.get("borrowIncentive.incentivePools");
-  const queryTarget = `${queryPkgId}::incentive_pools_query::incentive_pools_data`;
-  const args = [incentivePoolsId];
-  const queryResult = await address.cache.queryInspectTxn({
-    queryTarget,
-    args
-  });
-  const borrowIncentivePoolsQueryData = queryResult?.events[0].parsedJson;
-  return borrowIncentivePoolsQueryData;
-};
-var getBorrowIncentivePools = async (query, borrowIncentiveCoinNames = [
-  ...SUPPORT_BORROW_INCENTIVE_POOLS
-], indexer = false, coinPrices) => {
-  const borrowIncentivePools = {};
-  coinPrices = coinPrices ?? await query.utils.getCoinPrices() ?? {};
-  if (indexer) {
-    const borrowIncentivePoolsIndexer = await query.indexer.getBorrowIncentivePools();
-    const updateBorrowIncentivePool = (pool) => {
-      if (!borrowIncentiveCoinNames.includes(pool.coinName))
-        return;
-      pool.coinPrice = coinPrices[pool.coinName] ?? pool.coinPrice;
-      borrowIncentivePools[pool.coinName] = pool;
-    };
-    Object.values(borrowIncentivePoolsIndexer).forEach(
-      updateBorrowIncentivePool
-    );
-    return borrowIncentivePools;
-  }
-  const borrowIncentivePoolsQueryData = await queryBorrowIncentivePools(
-    query.address
+  const suppliedAmount = (0, import_bignumber5.default)(marketCoinAmount).plus((0, import_bignumber5.default)(sCoinAmount)).multipliedBy(marketPool?.conversionRate ?? 1);
+  const suppliedCoin = suppliedAmount.shiftedBy(-1 * coinDecimal);
+  const suppliedValue = suppliedCoin.multipliedBy(coinPrice ?? 0);
+  const marketCoinPrice = (0, import_bignumber5.default)(coinPrice ?? 0).multipliedBy(
+    marketPool?.conversionRate ?? 1
   );
-  for (const pool of borrowIncentivePoolsQueryData?.incentive_pools ?? []) {
-    const borrowIncentivePoolPoints = {};
-    const parsedBorrowIncentivePoolData = parseOriginBorrowIncentivePoolData(pool);
-    const poolCoinType = (0, import_utils7.normalizeStructTag)(pool.pool_type.name);
-    const poolCoinName = query.utils.parseCoinNameFromType(
-      poolCoinType
-    );
-    const poolCoinPrice = coinPrices?.[poolCoinName] ?? 0;
-    const poolCoinDecimal = query.utils.getCoinDecimal(poolCoinName);
-    if (!borrowIncentiveCoinNames.includes(poolCoinName)) {
-      continue;
-    }
-    for (const [coinName, poolPoint] of Object.entries(
-      parsedBorrowIncentivePoolData.poolPoints
-    )) {
-      const rewardCoinType = (0, import_utils7.normalizeStructTag)(poolPoint.pointType);
-      const rewardCoinName = query.utils.parseCoinNameFromType(
-        rewardCoinType
-      );
-      const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
-      const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
-      const symbol = query.utils.parseSymbol(rewardCoinName);
-      const coinDecimal = query.utils.getCoinDecimal(rewardCoinName);
-      const calculatedPoolPoint = calculateBorrowIncentivePoolPointData(
-        // parsedBorrowIncentivePoolData,
-        poolPoint,
-        rewardCoinPrice,
-        rewardCoinDecimal,
-        poolCoinPrice,
-        poolCoinDecimal
-      );
-      borrowIncentivePoolPoints[coinName] = {
-        symbol,
-        coinName: rewardCoinName,
-        coinType: rewardCoinType,
-        coinDecimal,
-        coinPrice: rewardCoinPrice,
-        points: poolPoint.points,
-        distributedPoint: poolPoint.distributedPoint,
-        weightedAmount: poolPoint.weightedAmount,
-        ...calculatedPoolPoint
-      };
-    }
-    const stakedAmount = (0, import_bignumber3.default)(parsedBorrowIncentivePoolData.staked);
-    const stakedCoin = stakedAmount.shiftedBy(-1 * poolCoinDecimal);
-    const stakedValue = stakedCoin.multipliedBy(poolCoinPrice);
-    borrowIncentivePools[poolCoinName] = {
-      coinName: poolCoinName,
-      symbol: query.utils.parseSymbol(poolCoinName),
-      coinType: poolCoinType,
-      coinDecimal: poolCoinDecimal,
-      coinPrice: poolCoinPrice,
-      stakedAmount: stakedAmount.toNumber(),
-      stakedCoin: stakedCoin.toNumber(),
-      stakedValue: stakedValue.toNumber(),
-      points: borrowIncentivePoolPoints
-    };
-  }
-  return borrowIncentivePools;
-};
-var queryBorrowIncentiveAccounts = async ({
-  utils
-}, obligationId, borrowIncentiveCoinNames = [
-  ...SUPPORT_BORROW_INCENTIVE_POOLS
-]) => {
-  const queryPkgId = utils.address.get("borrowIncentive.query");
-  const incentiveAccountsId = utils.address.get(
-    "borrowIncentive.incentiveAccounts"
-  );
-  const queryTarget = `${queryPkgId}::incentive_account_query::incentive_account_data`;
-  const args = [incentiveAccountsId, obligationId];
-  const queryResult = await utils.cache.queryInspectTxn({ queryTarget, args });
-  const borrowIncentiveAccountsQueryData = queryResult?.events[0]?.parsedJson;
-  const borrowIncentiveAccounts = Object.values(
-    borrowIncentiveAccountsQueryData?.pool_records ?? []
-  ).reduce((accounts, accountData) => {
-    const parsedBorrowIncentiveAccount = parseOriginBorrowIncentiveAccountData(accountData);
-    const poolType = parsedBorrowIncentiveAccount.poolType;
-    const coinName = utils.parseCoinNameFromType(poolType);
-    if (borrowIncentiveCoinNames && borrowIncentiveCoinNames.includes(coinName)) {
-      accounts[coinName] = parsedBorrowIncentiveAccount;
-    }
-    return accounts;
-  }, {});
-  return borrowIncentiveAccounts;
-};
-var getBindedObligationId = async ({
-  address
-}, veScaKeyId) => {
-  const borrowIncentiveObjectId = address.get("borrowIncentive.object");
-  const incentivePoolsId = address.get("borrowIncentive.incentivePools");
-  const veScaObjId = address.get("vesca.object");
-  const incentivePoolsResponse = await address.cache.queryGetObject(
-    incentivePoolsId,
-    {
-      showContent: true
-    }
-  );
-  if (incentivePoolsResponse?.data?.content?.dataType !== "moveObject")
-    return null;
-  const incentivePoolFields = incentivePoolsResponse.data.content.fields;
-  const veScaBindTableId = incentivePoolFields.ve_sca_bind.fields.id.id;
-  const keyType = `${borrowIncentiveObjectId}::typed_id::TypedID<${veScaObjId}::ve_sca::VeScaKey>`;
-  const veScaBindTableResponse = await address.cache.queryGetDynamicFieldObject(
-    {
-      parentId: veScaBindTableId,
-      name: {
-        type: keyType,
-        value: veScaKeyId
-      }
-    }
+  const unstakedMarketAmount = (0, import_bignumber5.default)(marketCoinAmount).plus(
+    (0, import_bignumber5.default)(sCoinAmount)
   );
-  if (veScaBindTableResponse?.data?.content?.dataType !== "moveObject")
-    return null;
-  const veScaBindTableFields = veScaBindTableResponse.data.content.fields;
-  const obligationId = veScaBindTableFields.value.fields.id;
-  return obligationId;
+  const unstakedMarketCoin = unstakedMarketAmount.shiftedBy(-1 * coinDecimal);
+  const availableSupplyAmount = (0, import_bignumber5.default)(coinAmount);
+  const availableSupplyCoin = availableSupplyAmount.shiftedBy(-1 * coinDecimal);
+  const availableWithdrawAmount = minBigNumber(
+    suppliedAmount,
+    marketPool?.supplyAmount ?? Infinity
+  ).plus(stakedAmount);
+  const availableWithdrawCoin = minBigNumber(
+    suppliedCoin,
+    marketPool?.supplyCoin ?? Infinity
+  ).plus(stakedCoin);
+  const lending = {
+    coinName: poolCoinName,
+    symbol: query.utils.parseSymbol(poolCoinName),
+    coinType: query.utils.parseCoinType(poolCoinName),
+    marketCoinType: query.utils.parseMarketCoinType(poolCoinName),
+    sCoinType: marketPool?.sCoinType ?? "",
+    coinDecimal,
+    coinPrice: coinPrice ?? 0,
+    conversionRate: marketPool?.conversionRate ?? 1,
+    marketCoinPrice: marketCoinPrice.toNumber(),
+    supplyApr: marketPool?.supplyApr ?? 0,
+    supplyApy: marketPool?.supplyApy ?? 0,
+    rewardApr: spool?.rewardApr ?? 0,
+    suppliedAmount: suppliedAmount.plus(stakedAmount).toNumber(),
+    suppliedCoin: suppliedCoin.plus(stakedCoin).toNumber(),
+    suppliedValue: suppliedValue.plus(stakedValue).toNumber(),
+    stakedMarketAmount: stakedMarketAmount.toNumber(),
+    stakedMarketCoin: stakedMarketCoin.toNumber(),
+    stakedAmount: stakedAmount.toNumber(),
+    stakedCoin: stakedCoin.toNumber(),
+    stakedValue: stakedValue.toNumber(),
+    unstakedMarketAmount: unstakedMarketAmount.toNumber(),
+    unstakedMarketCoin: unstakedMarketCoin.toNumber(),
+    unstakedAmount: suppliedAmount.toNumber(),
+    unstakedCoin: suppliedCoin.toNumber(),
+    unstakedValue: suppliedValue.toNumber(),
+    availableSupplyAmount: availableSupplyAmount.toNumber(),
+    availableSupplyCoin: availableSupplyCoin.toNumber(),
+    availableWithdrawAmount: availableWithdrawAmount.toNumber(),
+    availableWithdrawCoin: availableWithdrawCoin.toNumber(),
+    availableStakeAmount: unstakedMarketAmount.toNumber(),
+    availableStakeCoin: unstakedMarketCoin.toNumber(),
+    availableUnstakeAmount: availableUnstakeAmount.toNumber(),
+    availableUnstakeCoin: availableUnstakeCoin.toNumber(),
+    availableClaimAmount: availableClaimAmount.toNumber(),
+    availableClaimCoin: availableClaimCoin.toNumber(),
+    isIsolated: marketPool ? marketPool.isIsolated : false
+  };
+  return lending;
 };
-var getBindedVeScaKey = async ({
-  address
-}, obligationId) => {
-  const borrowIncentiveObjectId = address.get("borrowIncentive.object");
-  const incentiveAccountsId = address.get("borrowIncentive.incentiveAccounts");
-  const corePkg = address.get("core.object");
-  const incentiveAccountsObject = await address.cache.queryGetObject(
-    incentiveAccountsId,
-    {
-      showContent: true
-    }
+var getObligationAccounts = async (query, ownerAddress, indexer = false) => {
+  const coinPrices = await query.utils.getCoinPrices();
+  const market = await query.queryMarket(indexer, { coinPrices });
+  const [coinAmounts, obligations] = await Promise.all([
+    query.getCoinAmounts(void 0, ownerAddress),
+    query.getObligations(ownerAddress)
+  ]);
+  const obligationAccounts = {};
+  await Promise.allSettled(
+    obligations.map(async (obligation) => {
+      obligationAccounts[obligation.keyId] = await getObligationAccount(
+        query,
+        obligation.id,
+        ownerAddress,
+        indexer,
+        market,
+        coinPrices,
+        coinAmounts
+      );
+    })
   );
-  if (incentiveAccountsObject?.data?.content?.dataType !== "moveObject")
-    return null;
-  const incentiveAccountsTableId = incentiveAccountsObject.data.content.fields.accounts.fields.id.id;
-  const bindedIncentiveAcc = await address.cache.queryGetDynamicFieldObject({
-    parentId: incentiveAccountsTableId,
-    name: {
-      type: `${borrowIncentiveObjectId}::typed_id::TypedID<${corePkg}::obligation::Obligation>`,
-      value: obligationId
-    }
-  });
-  if (bindedIncentiveAcc?.data?.content?.dataType !== "moveObject")
-    return null;
-  const bindedIncentiveAccFields = bindedIncentiveAcc.data.content.fields;
-  return bindedIncentiveAccFields.value.fields.binded_ve_sca_key?.fields.id ?? null;
+  return obligationAccounts;
 };
-
-// src/queries/priceQuery.ts
-var getPythPrice = async ({
-  address
-}, assetCoinName, priceFeedObject) => {
-  const pythFeedObjectId = address.get(
-    `core.coins.${assetCoinName}.oracle.pyth.feedObject`
-  );
-  priceFeedObject = priceFeedObject || (await address.cache.queryGetObject(pythFeedObjectId, {
-    showContent: true
-  }))?.data;
-  if (priceFeedObject) {
-    const priceFeedPoolObject = priceFeedObject;
-    if (priceFeedPoolObject.content && "fields" in priceFeedPoolObject.content) {
-      const fields = priceFeedPoolObject.content.fields;
-      const expoMagnitude = Number(
-        fields.price_info.fields.price_feed.fields.price.fields.expo.fields.magnitude
+var getObligationAccount = async (query, obligationId, ownerAddress, indexer = false, market, coinPrices, coinAmounts) => {
+  const collateralAssetCoinNames = [
+    ...SUPPORT_COLLATERALS
+  ];
+  coinPrices = coinPrices ?? await query.utils.getCoinPrices(collateralAssetCoinNames);
+  market = market ?? await query.queryMarket(indexer, { coinPrices });
+  coinAmounts = coinAmounts || await query.getCoinAmounts(collateralAssetCoinNames, ownerAddress);
+  const [obligationQuery, borrowIncentivePools, borrowIncentiveAccounts] = await Promise.all([
+    query.queryObligation(obligationId),
+    query.getBorrowIncentivePools(void 0, indexer, {
+      coinPrices
+    }),
+    query.getBorrowIncentiveAccounts(obligationId)
+  ]);
+  const collaterals = {};
+  const debts = {};
+  const borrowIncentives = {};
+  let totalDepositedPools = 0;
+  let totalDepositedValue = (0, import_bignumber5.default)(0);
+  let totalBorrowCapacityValue = (0, import_bignumber5.default)(0);
+  let totalRequiredCollateralValue = (0, import_bignumber5.default)(0);
+  let totalBorrowedPools = 0;
+  let totalRewardedPools = 0;
+  let totalBorrowedValue = (0, import_bignumber5.default)(0);
+  let totalBorrowedValueWithWeight = (0, import_bignumber5.default)(0);
+  for (const assetCoinName of collateralAssetCoinNames) {
+    const collateral = obligationQuery?.collaterals.find((collateral2) => {
+      const collateralCoinName = query.utils.parseCoinNameFromType(
+        collateral2.type.name
       );
-      const expoNegative = Number(
-        fields.price_info.fields.price_feed.fields.price.fields.expo.fields.negative
+      return assetCoinName === collateralCoinName;
+    });
+    const marketCollateral = market.collaterals[assetCoinName];
+    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
+    const coinPrice = coinPrices?.[assetCoinName];
+    const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
+    if (marketCollateral && coinPrice) {
+      const depositedAmount = (0, import_bignumber5.default)(collateral?.amount ?? 0);
+      const depositedCoin = depositedAmount.shiftedBy(-1 * coinDecimal);
+      const depositedValue = depositedCoin.multipliedBy(coinPrice);
+      const borrowCapacityValue = depositedValue.multipliedBy(
+        marketCollateral.collateralFactor
       );
-      const priceMagnitude = Number(
-        fields.price_info.fields.price_feed.fields.price.fields.price.fields.magnitude
+      const requiredCollateralValue2 = depositedValue.multipliedBy(
+        marketCollateral.liquidationFactor
       );
-      const priceNegative = Number(
-        fields.price_info.fields.price_feed.fields.price.fields.price.fields.negative
+      const poolSizeAmount = (0, import_bignumber5.default)(marketCollateral.maxDepositAmount).minus(
+        marketCollateral.depositAmount
       );
-      return priceMagnitude * 10 ** ((expoNegative ? -1 : 1) * expoMagnitude) * (priceNegative ? -1 : 1);
-    }
-  }
-  return 0;
-};
-var getPythPrices = async ({
-  address
-}, assetCoinNames) => {
-  const pythPriceFeedIds = assetCoinNames.reduce(
-    (prev, assetCoinName) => {
-      const pythPriceFeed = address.get(
-        `core.coins.${assetCoinName}.oracle.pyth.feedObject`
+      const availableDepositAmount = minBigNumber(
+        (0, import_bignumber5.default)(coinAmount),
+        poolSizeAmount
       );
-      if (!prev[pythPriceFeed]) {
-        prev[pythPriceFeed] = [assetCoinName];
-      } else {
-        prev[pythPriceFeed].push(assetCoinName);
-      }
-      return prev;
-    },
-    {}
-  );
-  const priceFeedObjects = await address.cache.queryGetObjects(
-    Object.keys(pythPriceFeedIds),
-    { showContent: true }
-  );
-  const assetToPriceFeedMapping = priceFeedObjects.reduce(
-    (prev, priceFeedObject) => {
-      pythPriceFeedIds[priceFeedObject.objectId].forEach((assetCoinName) => {
-        prev[assetCoinName] = priceFeedObject;
-      });
-      return prev;
-    },
-    {}
-  );
-  return (await Promise.all(
-    Object.entries(assetToPriceFeedMapping).map(
-      async ([assetCoinName, priceFeedObject]) => ({
-        coinName: assetCoinName,
-        price: await getPythPrice(
-          { address },
-          assetCoinName,
-          priceFeedObject
-        )
-      })
-    )
-  )).reduce(
-    (prev, curr) => {
-      prev[curr.coinName] = curr.price;
-      return prev;
-    },
-    {}
-  );
-};
-
-// src/queries/portfolioQuery.ts
-var import_bignumber4 = __toESM(require("bignumber.js"));
-var getLendings = async (query, poolCoinNames = [...SUPPORT_POOLS], ownerAddress, indexer = false) => {
-  const marketCoinNames = poolCoinNames.map(
-    (poolCoinName) => query.utils.parseMarketCoinName(poolCoinName)
-  );
-  const stakeMarketCoinNames = marketCoinNames.filter(
-    (marketCoinName) => SUPPORT_SPOOLS.includes(marketCoinName)
-  );
-  const coinPrices = await query.utils.getCoinPrices(poolCoinNames);
-  const marketPools = await query.getMarketPools(poolCoinNames, indexer, {
-    coinPrices
-  });
-  const spools = await query.getSpools(stakeMarketCoinNames, indexer, {
-    marketPools,
-    coinPrices
-  });
-  const [coinAmounts, marketCoinAmounts, allStakeAccounts] = await Promise.all([
-    query.getCoinAmounts(poolCoinNames, ownerAddress),
-    query.getMarketCoinAmounts(marketCoinNames, ownerAddress),
-    query.getAllStakeAccounts(ownerAddress)
-  ]);
-  const lendings = {};
-  await Promise.allSettled(
-    poolCoinNames.map(async (poolCoinName) => {
-      const stakeMarketCoinName = stakeMarketCoinNames.find(
-        (marketCoinName2) => marketCoinName2 === query.utils.parseMarketCoinName(poolCoinName)
+      const availableDepositCoin = availableDepositAmount.shiftedBy(
+        -1 * coinDecimal
       );
-      const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
-      lendings[poolCoinName] = await getLending(
-        query,
-        poolCoinName,
-        ownerAddress,
-        indexer,
-        marketPools?.[poolCoinName],
-        stakeMarketCoinName ? spools[stakeMarketCoinName] : void 0,
-        stakeMarketCoinName ? allStakeAccounts[stakeMarketCoinName] : [],
-        coinAmounts?.[poolCoinName],
-        marketCoinAmounts?.[marketCoinName],
-        coinPrices?.[poolCoinName] ?? 0
+      totalDepositedValue = totalDepositedValue.plus(depositedValue);
+      totalBorrowCapacityValue = totalBorrowCapacityValue.plus(borrowCapacityValue);
+      totalRequiredCollateralValue = totalRequiredCollateralValue.plus(
+        requiredCollateralValue2
       );
-    })
-  );
-  return lendings;
-};
-var getLending = async (query, poolCoinName, ownerAddress, indexer = false, marketPool, spool, stakeAccounts, coinAmount, marketCoinAmount, coinPrice, sCoinAmount) => {
-  const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
-  coinPrice = coinPrice ?? (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName] ?? 0;
-  marketPool = marketPool ?? await query.getMarketPool(poolCoinName, indexer, {
-    coinPrice
-  });
-  if (!marketPool)
-    throw new Error(`Failed to fetch marketPool for ${poolCoinName}`);
-  spool = spool ?? SUPPORT_SPOOLS.includes(marketCoinName) ? await query.getSpool(
-    marketCoinName,
-    indexer,
-    {
-      marketPool,
-      coinPrices: {
-        [poolCoinName]: coinPrice
+      if (depositedAmount.isGreaterThan(0)) {
+        totalDepositedPools++;
       }
+      collaterals[assetCoinName] = {
+        coinName: assetCoinName,
+        coinType: query.utils.parseCoinType(assetCoinName),
+        symbol: query.utils.parseSymbol(assetCoinName),
+        coinDecimal,
+        coinPrice,
+        depositedAmount: depositedAmount.toNumber(),
+        depositedCoin: depositedCoin.toNumber(),
+        depositedValue: depositedValue.toNumber(),
+        borrowCapacityValue: borrowCapacityValue.toNumber(),
+        requiredCollateralValue: requiredCollateralValue2.toNumber(),
+        availableDepositAmount: availableDepositAmount.toNumber(),
+        availableDepositCoin: availableDepositCoin.toNumber(),
+        availableWithdrawAmount: 0,
+        availableWithdrawCoin: 0
+      };
     }
-  ) : void 0;
-  stakeAccounts = stakeAccounts || SUPPORT_SPOOLS.includes(marketCoinName) ? await query.getStakeAccounts(
-    marketCoinName,
-    ownerAddress
-  ) : [];
-  coinAmount = coinAmount || await query.getCoinAmount(poolCoinName, ownerAddress);
-  marketCoinAmount = marketCoinAmount || await query.getMarketCoinAmount(marketCoinName, ownerAddress);
-  sCoinAmount = sCoinAmount || await query.getSCoinAmount(marketCoinName, ownerAddress);
-  const coinDecimal = query.utils.getCoinDecimal(poolCoinName);
-  let stakedMarketAmount = (0, import_bignumber4.default)(0);
-  let stakedMarketCoin = (0, import_bignumber4.default)(0);
-  let stakedAmount = (0, import_bignumber4.default)(0);
-  let stakedCoin = (0, import_bignumber4.default)(0);
-  let stakedValue = (0, import_bignumber4.default)(0);
-  let availableUnstakeAmount = (0, import_bignumber4.default)(0);
-  let availableUnstakeCoin = (0, import_bignumber4.default)(0);
-  let availableClaimAmount = (0, import_bignumber4.default)(0);
-  let availableClaimCoin = (0, import_bignumber4.default)(0);
-  if (spool) {
-    for (const stakeAccount of stakeAccounts) {
-      const accountStakedMarketCoinAmount = (0, import_bignumber4.default)(stakeAccount.staked);
-      const accountStakedMarketCoin = accountStakedMarketCoinAmount.shiftedBy(
-        -1 * spool.coinDecimal
-      );
-      const accountStakedAmount = accountStakedMarketCoinAmount.multipliedBy(
-        marketPool?.conversionRate ?? 1
-      );
-      const accountStakedCoin = accountStakedAmount.shiftedBy(
-        -1 * spool.coinDecimal
-      );
-      const accountStakedValue = accountStakedCoin.multipliedBy(
-        spool.coinPrice
-      );
-      stakedMarketAmount = stakedMarketAmount.plus(
-        accountStakedMarketCoinAmount
+  }
+  const borrowAssetCoinNames = [
+    .../* @__PURE__ */ new Set([...Object.values(market.pools).map((pool) => pool.coinName)])
+  ];
+  for (const assetCoinName of borrowAssetCoinNames) {
+    const debt = obligationQuery?.debts.find((debt2) => {
+      const poolCoinName = query.utils.parseCoinNameFromType(
+        debt2.type.name
       );
-      stakedMarketCoin = stakedMarketCoin.plus(accountStakedMarketCoin);
-      stakedAmount = stakedAmount.plus(accountStakedAmount);
-      stakedCoin = stakedCoin.plus(accountStakedCoin);
-      stakedValue = stakedValue.plus(accountStakedValue);
-      availableUnstakeAmount = availableUnstakeAmount.plus(
-        accountStakedMarketCoinAmount
+      return assetCoinName === poolCoinName;
+    });
+    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_bignumber5.default)(debt?.amount ?? 0).multipliedBy(
+        increasedRate + 1
       );
-      availableUnstakeCoin = availableUnstakeAmount.shiftedBy(
-        -1 * spool.coinDecimal
+      const borrowedCoin = borrowedAmount.shiftedBy(-1 * coinDecimal);
+      const requiredRepayAmount = borrowedAmount;
+      const requiredRepayCoin = requiredRepayAmount.shiftedBy(-1 * coinDecimal);
+      const availableRepayAmount = (0, import_bignumber5.default)(coinAmount);
+      const availableRepayCoin = availableRepayAmount.shiftedBy(
+        -1 * coinDecimal
       );
-      const baseIndexRate = 1e9;
-      const increasedPointRate = spool.currentPointIndex ? (0, import_bignumber4.default)(spool.currentPointIndex - stakeAccount.index).dividedBy(
-        baseIndexRate
-      ) : 1;
-      availableClaimAmount = availableClaimAmount.plus(
-        accountStakedMarketCoinAmount.multipliedBy(increasedPointRate).plus(stakeAccount.points).multipliedBy(spool.exchangeRateNumerator).dividedBy(spool.exchangeRateDenominator)
+      const borrowedValue = requiredRepayCoin.multipliedBy(coinPrice);
+      const borrowedValueWithWeight = borrowedValue.multipliedBy(
+        marketPool.borrowWeight
       );
-      availableClaimCoin = availableClaimAmount.shiftedBy(
-        -1 * spool.rewardCoinDecimal
+      totalBorrowedValue = totalBorrowedValue.plus(borrowedValue);
+      totalBorrowedValueWithWeight = totalBorrowedValueWithWeight.plus(
+        borrowedValueWithWeight
       );
+      if (borrowedAmount.isGreaterThan(0)) {
+        totalBorrowedPools++;
+      }
+      debts[assetCoinName] = {
+        coinName: assetCoinName,
+        coinType: query.utils.parseCoinType(assetCoinName),
+        symbol: query.utils.parseSymbol(assetCoinName),
+        coinDecimal,
+        coinPrice,
+        borrowedAmount: borrowedAmount.toNumber(),
+        borrowedCoin: borrowedCoin.toNumber(),
+        borrowedValue: borrowedValue.toNumber(),
+        borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
+        borrowIndex: Number(debt?.borrowIndex ?? 0),
+        requiredRepayAmount: requiredRepayAmount.toNumber(),
+        requiredRepayCoin: requiredRepayCoin.toNumber(),
+        availableBorrowAmount: 0,
+        availableBorrowCoin: 0,
+        availableRepayAmount: availableRepayAmount.toNumber(),
+        availableRepayCoin: availableRepayCoin.toNumber()
+      };
     }
   }
-  const suppliedAmount = (0, import_bignumber4.default)(marketCoinAmount).plus((0, import_bignumber4.default)(sCoinAmount)).multipliedBy(marketPool?.conversionRate ?? 1);
-  const suppliedCoin = suppliedAmount.shiftedBy(-1 * coinDecimal);
-  const suppliedValue = suppliedCoin.multipliedBy(coinPrice ?? 0);
-  const marketCoinPrice = (0, import_bignumber4.default)(coinPrice ?? 0).multipliedBy(
-    marketPool?.conversionRate ?? 1
-  );
-  const unstakedMarketAmount = (0, import_bignumber4.default)(marketCoinAmount).plus(
-    (0, import_bignumber4.default)(sCoinAmount)
-  );
-  const unstakedMarketCoin = unstakedMarketAmount.shiftedBy(-1 * coinDecimal);
-  const availableSupplyAmount = (0, import_bignumber4.default)(coinAmount);
-  const availableSupplyCoin = availableSupplyAmount.shiftedBy(-1 * coinDecimal);
-  const availableWithdrawAmount = minBigNumber(
-    suppliedAmount,
-    marketPool?.supplyAmount ?? Infinity
-  ).plus(stakedAmount);
-  const availableWithdrawCoin = minBigNumber(
-    suppliedCoin,
-    marketPool?.supplyCoin ?? Infinity
-  ).plus(stakedCoin);
-  const lending = {
-    coinName: poolCoinName,
-    symbol: query.utils.parseSymbol(poolCoinName),
-    coinType: query.utils.parseCoinType(poolCoinName),
-    marketCoinType: query.utils.parseMarketCoinType(poolCoinName),
-    sCoinType: marketPool?.sCoinType ?? "",
-    coinDecimal,
-    coinPrice: coinPrice ?? 0,
-    conversionRate: marketPool?.conversionRate ?? 1,
-    marketCoinPrice: marketCoinPrice.toNumber(),
-    supplyApr: marketPool?.supplyApr ?? 0,
-    supplyApy: marketPool?.supplyApy ?? 0,
-    rewardApr: spool?.rewardApr ?? 0,
-    suppliedAmount: suppliedAmount.plus(stakedAmount).toNumber(),
-    suppliedCoin: suppliedCoin.plus(stakedCoin).toNumber(),
-    suppliedValue: suppliedValue.plus(stakedValue).toNumber(),
-    stakedMarketAmount: stakedMarketAmount.toNumber(),
-    stakedMarketCoin: stakedMarketCoin.toNumber(),
-    stakedAmount: stakedAmount.toNumber(),
-    stakedCoin: stakedCoin.toNumber(),
-    stakedValue: stakedValue.toNumber(),
-    unstakedMarketAmount: unstakedMarketAmount.toNumber(),
-    unstakedMarketCoin: unstakedMarketCoin.toNumber(),
-    unstakedAmount: suppliedAmount.toNumber(),
-    unstakedCoin: suppliedCoin.toNumber(),
-    unstakedValue: suppliedValue.toNumber(),
-    availableSupplyAmount: availableSupplyAmount.toNumber(),
-    availableSupplyCoin: availableSupplyCoin.toNumber(),
-    availableWithdrawAmount: availableWithdrawAmount.toNumber(),
-    availableWithdrawCoin: availableWithdrawCoin.toNumber(),
-    availableStakeAmount: unstakedMarketAmount.toNumber(),
-    availableStakeCoin: unstakedMarketCoin.toNumber(),
-    availableUnstakeAmount: availableUnstakeAmount.toNumber(),
-    availableUnstakeCoin: availableUnstakeCoin.toNumber(),
-    availableClaimAmount: availableClaimAmount.toNumber(),
-    availableClaimCoin: availableClaimCoin.toNumber(),
-    isIsolated: marketPool ? marketPool.isIsolated : false
+  for (const [poolCoinName, borrowIncentiveAccount] of Object.entries(
+    borrowIncentiveAccounts
+  )) {
+    const coinName = poolCoinName;
+    const borrowIncentivePool = borrowIncentivePools[coinName];
+    if (borrowIncentivePool) {
+      const rewards = [];
+      for (const rewardCoinName of SUPPORT_BORROW_INCENTIVE_REWARDS) {
+        const accountPoint = borrowIncentiveAccount.pointList[rewardCoinName];
+        const poolPoint = borrowIncentivePool.points[rewardCoinName];
+        if (accountPoint && poolPoint) {
+          let availableClaimAmount = (0, import_bignumber5.default)(0);
+          let availableClaimCoin = (0, import_bignumber5.default)(0);
+          const accountBorrowedAmount = (0, import_bignumber5.default)(accountPoint.weightedAmount);
+          const baseIndexRate = 1e9;
+          const increasedPointRate = poolPoint.currentPointIndex ? Math.max(
+            (0, import_bignumber5.default)(poolPoint.currentPointIndex - accountPoint.index).dividedBy(baseIndexRate).toNumber(),
+            0
+          ) : 1;
+          availableClaimAmount = availableClaimAmount.plus(
+            accountBorrowedAmount.multipliedBy(increasedPointRate).plus(accountPoint.points)
+          );
+          availableClaimCoin = availableClaimAmount.shiftedBy(
+            -1 * poolPoint.coinDecimal
+          );
+          const weightScale = (0, import_bignumber5.default)(1e12);
+          const boostValue = (0, import_bignumber5.default)(accountPoint.weightedAmount).div(
+            (0, import_bignumber5.default)(borrowIncentiveAccount.debtAmount).multipliedBy(poolPoint.baseWeight).dividedBy(weightScale)
+          ).isFinite() ? (0, import_bignumber5.default)(accountPoint.weightedAmount).div(
+            (0, import_bignumber5.default)(borrowIncentiveAccount.debtAmount).multipliedBy(poolPoint.baseWeight).dividedBy(weightScale)
+          ).toNumber() : 1;
+          if (availableClaimAmount.isGreaterThanOrEqualTo(0)) {
+            rewards.push({
+              coinName: poolPoint.coinName,
+              coinType: poolPoint.coinType,
+              symbol: poolPoint.symbol,
+              coinDecimal: poolPoint.coinDecimal,
+              coinPrice: poolPoint.coinPrice,
+              availableClaimAmount: availableClaimAmount.toNumber(),
+              availableClaimCoin: availableClaimCoin.toNumber(),
+              boostValue
+            });
+          }
+        }
+      }
+      if (Object.keys(borrowIncentivePool.points).some((coinName2) => {
+        const rewardApr = borrowIncentivePool.points[coinName2]?.rewardApr;
+        return rewardApr !== Infinity && typeof rewardApr == "number" && rewardApr > 0;
+      }) && borrowIncentiveAccount.debtAmount > 0) {
+        totalRewardedPools++;
+      }
+      borrowIncentives[coinName] = {
+        coinName: borrowIncentivePool.coinName,
+        coinType: borrowIncentivePool.coinType,
+        symbol: borrowIncentivePool.symbol,
+        coinDecimal: borrowIncentivePool.coinDecimal,
+        coinPrice: borrowIncentivePool.coinPrice,
+        rewards
+      };
+    }
+  }
+  let riskLevel = totalRequiredCollateralValue.isZero() ? (0, import_bignumber5.default)(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
+  riskLevel = riskLevel.isLessThan(1) ? riskLevel : (0, import_bignumber5.default)(1);
+  const accountBalanceValue = totalDepositedValue.minus(totalBorrowedValue).isGreaterThan(0) ? totalDepositedValue.minus(totalBorrowedValue) : (0, import_bignumber5.default)(0);
+  const availableCollateralValue = totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight).isGreaterThan(0) ? totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight) : (0, import_bignumber5.default)(0);
+  const requiredCollateralValue = totalBorrowedValueWithWeight.isGreaterThan(0) ? totalRequiredCollateralValue : (0, import_bignumber5.default)(0);
+  const unhealthyCollateralValue = totalBorrowedValueWithWeight.minus(requiredCollateralValue).isGreaterThan(0) ? totalBorrowedValueWithWeight.minus(requiredCollateralValue) : (0, import_bignumber5.default)(0);
+  const obligationAccount = {
+    obligationId,
+    // Deposited collateral value (collateral balance)
+    totalDepositedValue: totalDepositedValue.toNumber(),
+    // Borrowed debt value (liabilities balance)
+    totalBorrowedValue: totalBorrowedValue.toNumber(),
+    // The difference between the user’s actual deposit and loan (remaining balance)
+    totalBalanceValue: accountBalanceValue.toNumber(),
+    // Effective collateral value (the actual collateral value included in the calculation).
+    totalBorrowCapacityValue: totalBorrowCapacityValue.toNumber(),
+    // Available collateral value (the remaining collateral value that can be borrowed).
+    totalAvailableCollateralValue: availableCollateralValue.toNumber(),
+    // Available debt value (the actual borrowing value included in the calculation).
+    totalBorrowedValueWithWeight: totalBorrowedValueWithWeight.toNumber(),
+    // Required collateral value (avoid be liquidated).
+    totalRequiredCollateralValue: requiredCollateralValue.toNumber(),
+    // Unliquidated collateral value (pending liquidation).
+    totalUnhealthyCollateralValue: unhealthyCollateralValue.toNumber(),
+    totalRiskLevel: riskLevel.toNumber(),
+    totalDepositedPools,
+    totalBorrowedPools,
+    totalRewardedPools,
+    collaterals,
+    debts,
+    borrowIncentives
   };
-  return lending;
-};
-var getObligationAccounts = async (query, ownerAddress, indexer = false) => {
-  const coinPrices = await query.utils.getCoinPrices();
-  const market = await query.queryMarket(indexer, { coinPrices });
-  const [coinAmounts, obligations] = await Promise.all([
-    query.getCoinAmounts(void 0, ownerAddress),
-    query.getObligations(ownerAddress)
-  ]);
-  const obligationAccounts = {};
-  await Promise.allSettled(
-    obligations.map(async (obligation) => {
-      obligationAccounts[obligation.keyId] = await getObligationAccount(
-        query,
-        obligation.id,
-        ownerAddress,
-        indexer,
-        market,
-        coinPrices,
-        coinAmounts
+  for (const [collateralCoinName, obligationCollateral] of Object.entries(
+    obligationAccount.collaterals
+  )) {
+    const marketCollateral = market.collaterals[collateralCoinName];
+    if (marketCollateral) {
+      let estimatedAvailableWithdrawAmount = (0, import_bignumber5.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_bignumber5.default)(obligationCollateral.depositedAmount)
+      ) : minBigNumber(
+        estimatedAvailableWithdrawAmount.multipliedBy(
+          estimatedFactor(
+            (0, import_bignumber5.default)(obligationAccount.totalAvailableCollateralValue).dividedBy(marketCollateral.collateralFactor).toNumber(),
+            3,
+            "increase"
+          )
+        ).toNumber(),
+        obligationCollateral.depositedAmount,
+        marketCollateral.depositAmount
       );
-    })
-  );
-  return obligationAccounts;
+      obligationCollateral.availableWithdrawAmount = estimatedAvailableWithdrawAmount.toNumber();
+      obligationCollateral.availableWithdrawCoin = estimatedAvailableWithdrawAmount.shiftedBy(-1 * obligationCollateral.coinDecimal).toNumber();
+    }
+  }
+  for (const [poolCoinName, obligationDebt] of Object.entries(
+    obligationAccount.debts
+  )) {
+    const marketPool = market.pools[poolCoinName];
+    if (marketPool) {
+      const estimatedRequiredRepayAmount = (0, import_bignumber5.default)(
+        obligationDebt.requiredRepayAmount
+      ).multipliedBy(
+        estimatedFactor(obligationDebt.borrowedValue, 3, "decrease")
+      );
+      let estimatedAvailableBorrowAmount = (0, import_bignumber5.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"
+          )
+        ).toNumber(),
+        marketPool.supplyAmount
+      ) : (0, import_bignumber5.default)(0);
+      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 getObligationAccount = async (query, obligationId, ownerAddress, indexer = false, market, coinPrices, coinAmounts) => {
-  const collateralAssetCoinNames = [
-    ...SUPPORT_COLLATERALS
-  ];
-  coinPrices = coinPrices ?? await query.utils.getCoinPrices(collateralAssetCoinNames);
-  market = market ?? await query.queryMarket(indexer, { coinPrices });
-  coinAmounts = coinAmounts || await query.getCoinAmounts(collateralAssetCoinNames, ownerAddress);
-  const [obligationQuery, borrowIncentivePools, borrowIncentiveAccounts] = await Promise.all([
-    query.queryObligation(obligationId),
-    query.getBorrowIncentivePools(void 0, indexer, {
-      coinPrices
-    }),
-    query.getBorrowIncentiveAccounts(obligationId)
-  ]);
-  const collaterals = {};
-  const debts = {};
-  const borrowIncentives = {};
-  let totalDepositedPools = 0;
-  let totalDepositedValue = (0, import_bignumber4.default)(0);
-  let totalBorrowCapacityValue = (0, import_bignumber4.default)(0);
-  let totalRequiredCollateralValue = (0, import_bignumber4.default)(0);
-  let totalBorrowedPools = 0;
-  let totalRewardedPools = 0;
-  let totalBorrowedValue = (0, import_bignumber4.default)(0);
-  let totalBorrowedValueWithWeight = (0, import_bignumber4.default)(0);
-  for (const assetCoinName of collateralAssetCoinNames) {
-    const collateral = obligationQuery?.collaterals.find((collateral2) => {
-      const collateralCoinName = query.utils.parseCoinNameFromType(
-        collateral2.type.name
+var getTotalValueLocked = async (query, indexer = false) => {
+  const market = await query.queryMarket(indexer);
+  let supplyValue = (0, import_bignumber5.default)(0);
+  let borrowValue = (0, import_bignumber5.default)(0);
+  if (indexer) {
+    const tvlIndexer = await query.indexer.getTotalValueLocked();
+    const tvl2 = {
+      supplyValue: tvlIndexer.supplyValue,
+      supplyValueChangeRatio: tvlIndexer.supplyValueChangeRatio,
+      borrowValue: tvlIndexer.borrowValue,
+      borrowValueChangeRatio: tvlIndexer.borrowValueChangeRatio,
+      totalValue: tvlIndexer.totalValue,
+      totalValueChangeRatio: tvlIndexer.totalValueChangeRatio
+    };
+    return tvl2;
+  }
+  for (const pool of Object.values(market.pools)) {
+    supplyValue = supplyValue.plus(
+      (0, import_bignumber5.default)(pool.supplyCoin).multipliedBy(pool.coinPrice)
+    );
+    borrowValue = borrowValue.plus(
+      (0, import_bignumber5.default)(pool.borrowCoin).multipliedBy(pool.coinPrice)
+    );
+  }
+  for (const collateral of Object.values(market.collaterals)) {
+    supplyValue = supplyValue.plus(
+      (0, import_bignumber5.default)(collateral.depositCoin).multipliedBy(collateral.coinPrice)
+    );
+  }
+  const tvl = {
+    supplyValue: supplyValue.toNumber(),
+    borrowValue: borrowValue.toNumber(),
+    totalValue: supplyValue.minus(borrowValue).toNumber()
+  };
+  return tvl;
+};
+
+// src/queries/priceQuery.ts
+var getPythPrice = async ({
+  address
+}, assetCoinName, priceFeedObject) => {
+  const pythFeedObjectId = address.get(
+    `core.coins.${assetCoinName}.oracle.pyth.feedObject`
+  );
+  priceFeedObject = priceFeedObject || (await address.cache.queryGetObject(pythFeedObjectId, {
+    showContent: true
+  }))?.data;
+  if (priceFeedObject) {
+    const priceFeedPoolObject = priceFeedObject;
+    if (priceFeedPoolObject.content && "fields" in priceFeedPoolObject.content) {
+      const fields = priceFeedPoolObject.content.fields;
+      const expoMagnitude = Number(
+        fields.price_info.fields.price_feed.fields.price.fields.expo.fields.magnitude
       );
-      return assetCoinName === collateralCoinName;
-    });
-    const marketCollateral = market.collaterals[assetCoinName];
-    const coinDecimal = query.utils.getCoinDecimal(assetCoinName);
-    const coinPrice = coinPrices?.[assetCoinName];
-    const coinAmount = coinAmounts?.[assetCoinName] ?? 0;
-    if (marketCollateral && coinPrice) {
-      const depositedAmount = (0, import_bignumber4.default)(collateral?.amount ?? 0);
-      const depositedCoin = depositedAmount.shiftedBy(-1 * coinDecimal);
-      const depositedValue = depositedCoin.multipliedBy(coinPrice);
-      const borrowCapacityValue = depositedValue.multipliedBy(
-        marketCollateral.collateralFactor
+      const expoNegative = Number(
+        fields.price_info.fields.price_feed.fields.price.fields.expo.fields.negative
       );
-      const requiredCollateralValue2 = depositedValue.multipliedBy(
-        marketCollateral.liquidationFactor
+      const priceMagnitude = Number(
+        fields.price_info.fields.price_feed.fields.price.fields.price.fields.magnitude
       );
-      const poolSizeAmount = (0, import_bignumber4.default)(marketCollateral.maxDepositAmount).minus(
-        marketCollateral.depositAmount
+      const priceNegative = Number(
+        fields.price_info.fields.price_feed.fields.price.fields.price.fields.negative
       );
-      const availableDepositAmount = minBigNumber(
-        (0, import_bignumber4.default)(coinAmount),
-        poolSizeAmount
+      return priceMagnitude * 10 ** ((expoNegative ? -1 : 1) * expoMagnitude) * (priceNegative ? -1 : 1);
+    }
+  }
+  return 0;
+};
+var getPythPrices = async ({
+  address
+}, assetCoinNames) => {
+  const pythPriceFeedIds = assetCoinNames.reduce(
+    (prev, assetCoinName) => {
+      const pythPriceFeed = address.get(
+        `core.coins.${assetCoinName}.oracle.pyth.feedObject`
+      );
+      if (!prev[pythPriceFeed]) {
+        prev[pythPriceFeed] = [assetCoinName];
+      } else {
+        prev[pythPriceFeed].push(assetCoinName);
+      }
+      return prev;
+    },
+    {}
+  );
+  const priceFeedObjects = await address.cache.queryGetObjects(
+    Object.keys(pythPriceFeedIds),
+    { showContent: true }
+  );
+  const assetToPriceFeedMapping = priceFeedObjects.reduce(
+    (prev, priceFeedObject) => {
+      pythPriceFeedIds[priceFeedObject.objectId].forEach((assetCoinName) => {
+        prev[assetCoinName] = priceFeedObject;
+      });
+      return prev;
+    },
+    {}
+  );
+  return (await Promise.all(
+    Object.entries(assetToPriceFeedMapping).map(
+      async ([assetCoinName, priceFeedObject]) => ({
+        coinName: assetCoinName,
+        price: await getPythPrice(
+          { address },
+          assetCoinName,
+          priceFeedObject
+        )
+      })
+    )
+  )).reduce(
+    (prev, curr) => {
+      prev[curr.coinName] = curr.price;
+      return prev;
+    },
+    {}
+  );
+};
+
+// src/queries/referralQuery.ts
+var queryVeScaKeyIdFromReferralBindings = async (address, refereeAddress) => {
+  const referralBindingTableId = address.get("referral.bindingTableId");
+  const referralBindResponse = await address.cache.queryGetDynamicFieldObject({
+    parentId: referralBindingTableId,
+    name: {
+      type: "address",
+      value: refereeAddress
+    }
+  });
+  if (referralBindResponse?.data?.content?.dataType !== "moveObject")
+    return null;
+  const fields = referralBindResponse.data.content.fields;
+  return fields.value;
+};
+
+// src/queries/sCoinQuery.ts
+var import_bcs = require("@mysten/sui/bcs");
+var import_assert = __toESM(require("assert"));
+var import_bignumber6 = __toESM(require("bignumber.js"));
+var getSCoinTotalSupply = async ({
+  utils
+}, sCoinName) => {
+  const sCoinPkgId = utils.address.get("scoin.id");
+  const args = [utils.getSCoinTreasury(sCoinName)];
+  const typeArgs = [
+    utils.parseSCoinType(sCoinName),
+    utils.parseUnderlyingSCoinType(sCoinName)
+  ];
+  const queryTarget = `${sCoinPkgId}::s_coin_converter::total_supply`;
+  const queryResults = await utils.cache.queryInspectTxn({
+    queryTarget,
+    args,
+    typeArgs
+  });
+  const results = queryResults?.results;
+  if (results && results[0]?.returnValues) {
+    const value = Uint8Array.from(results[0].returnValues[0][0]);
+    const type = results[0].returnValues[0][1];
+    (0, import_assert.default)(type === "u64", "Result type is not u64");
+    return (0, import_bignumber6.default)(import_bcs.bcs.u64().parse(value)).shiftedBy(utils.getCoinDecimal(utils.parseCoinName(sCoinName))).toNumber();
+  }
+  return 0;
+};
+var getSCoinAmounts = async ({
+  utils
+}, sCoinNames = [...SUPPORT_SCOIN], ownerAddress) => {
+  const owner = ownerAddress || utils.suiKit.currentAddress();
+  const sCoins2 = {};
+  await Promise.allSettled(
+    sCoinNames.map(async (sCoinName) => {
+      const sCoin = await getSCoinAmount({ utils }, sCoinName, owner);
+      sCoins2[sCoinName] = sCoin;
+    })
+  );
+  return sCoins2;
+};
+var getSCoinAmount = async ({
+  utils
+}, sCoinName, ownerAddress) => {
+  const owner = ownerAddress || utils.suiKit.currentAddress();
+  const sCoinType = utils.parseSCoinType(sCoinName);
+  const amount = await utils.cache.queryGetCoinBalance({
+    owner,
+    coinType: sCoinType
+  });
+  return (0, import_bignumber6.default)(amount).toNumber();
+};
+var isSupportStakeCoins = (value) => {
+  return SUPPORT_SCOIN.includes(value);
+};
+var checkAssetParams = (fromSCoin, toSCoin) => {
+  if (fromSCoin === toSCoin)
+    throw new Error("fromAsset and toAsset must be different");
+  if (!isSupportStakeCoins(fromSCoin))
+    throw new Error("fromAsset is not supported");
+  if (!isSupportStakeCoins(toSCoin)) {
+    throw new Error("toAsset is not supported");
+  }
+};
+var getSCoinSwapRate = async (query, fromSCoin, toSCoin, underlyingCoinPrice) => {
+  checkAssetParams(fromSCoin, toSCoin);
+  const fromCoinName = query.utils.parseCoinName(fromSCoin);
+  const toCoinName = query.utils.parseCoinName(toSCoin);
+  const marketPools = await Promise.all([
+    query.getMarketPool(fromCoinName, false),
+    query.getMarketPool(toCoinName, false)
+  ]);
+  if (marketPools.some((pool) => !pool))
+    throw new Error("Failed to fetch the lendings data");
+  if (marketPools.some((pool) => pool?.conversionRate === 0)) {
+    throw new Error("Conversion rate cannot be zero");
+  }
+  const ScoinAToARate = marketPools[0].conversionRate;
+  const BtoSCoinBRate = 1 / marketPools[1].conversionRate;
+  const calcAtoBRate = async () => {
+    const prices = await query.utils.getCoinPrices([fromCoinName, toCoinName]);
+    if (!prices[fromCoinName] || !prices[toCoinName]) {
+      throw new Error("Failed to fetch the coin prices");
+    }
+    if (prices[toCoinName] === 0) {
+      throw new Error("Price of toCoin cannot be zero");
+    }
+    return prices[fromCoinName] / prices[toCoinName];
+  };
+  const AtoBRate = underlyingCoinPrice ?? await calcAtoBRate();
+  return (0, import_bignumber6.default)(ScoinAToARate).multipliedBy(AtoBRate).multipliedBy(BtoSCoinBRate).toNumber();
+};
+
+// src/queries/spoolQuery.ts
+var import_utils8 = require("@mysten/sui/utils");
+var getSpools = async (query, stakeMarketCoinNames = [...SUPPORT_SPOOLS], indexer = false, marketPools, coinPrices) => {
+  const stakeCoinNames = stakeMarketCoinNames.map(
+    (stakeMarketCoinName) => query.utils.parseCoinName(stakeMarketCoinName)
+  );
+  coinPrices = coinPrices ?? await query.utils.getCoinPrices() ?? {};
+  marketPools = marketPools ?? await query.getMarketPools(stakeCoinNames, indexer);
+  if (!marketPools)
+    throw new Error(`Fail to fetch marketPools for ${stakeCoinNames}`);
+  const spools = {};
+  if (indexer) {
+    const spoolsIndexer = await query.indexer.getSpools();
+    const updateSpools = (spool) => {
+      if (!stakeMarketCoinNames.includes(spool.marketCoinName))
+        return;
+      const coinName = query.utils.parseCoinName(
+        spool.marketCoinName
       );
-      const availableDepositCoin = availableDepositAmount.shiftedBy(
-        -1 * coinDecimal
+      const rewardCoinName = query.utils.getSpoolRewardCoinName(
+        spool.marketCoinName
       );
-      totalDepositedValue = totalDepositedValue.plus(depositedValue);
-      totalBorrowCapacityValue = totalBorrowCapacityValue.plus(borrowCapacityValue);
-      totalRequiredCollateralValue = totalRequiredCollateralValue.plus(
-        requiredCollateralValue2
+      const marketPool = marketPools[coinName];
+      spool.coinPrice = coinPrices[coinName] ?? spool.coinPrice;
+      spool.marketCoinPrice = coinPrices[coinName] ? (coinPrices[coinName] ?? 0) * (marketPool ? marketPool.conversionRate : 0) : spool.marketCoinPrice;
+      spool.rewardCoinPrice = coinPrices[rewardCoinName] ?? spool.rewardCoinPrice;
+      spools[spool.marketCoinName] = spool;
+    };
+    Object.values(spoolsIndexer).forEach(updateSpools);
+    return spools;
+  }
+  for (const stakeMarketCoinName of stakeMarketCoinNames) {
+    const stakeCoinName = query.utils.parseCoinName(stakeMarketCoinName);
+    const spool = await getSpool(
+      query,
+      stakeMarketCoinName,
+      indexer,
+      marketPools[stakeCoinName],
+      coinPrices
+    );
+    if (spool) {
+      spools[stakeMarketCoinName] = spool;
+    }
+  }
+  return spools;
+};
+var getSpool = async (query, marketCoinName, indexer = false, marketPool, coinPrices) => {
+  const coinName = query.utils.parseCoinName(marketCoinName);
+  marketPool = marketPool || await query.getMarketPool(coinName, indexer);
+  if (!marketPool) {
+    throw new Error(`Fail to fetch marketPool for ${coinName}`);
+  }
+  const poolId = query.address.get(`spool.pools.${marketCoinName}.id`);
+  const rewardPoolId = query.address.get(
+    `spool.pools.${marketCoinName}.rewardPoolId`
+  );
+  let spool = void 0;
+  coinPrices = coinPrices || await query.utils.getCoinPrices([coinName]);
+  if (indexer) {
+    const spoolIndexer = await query.indexer.getSpool(marketCoinName);
+    const coinName2 = query.utils.parseCoinName(marketCoinName);
+    const rewardCoinName2 = query.utils.getSpoolRewardCoinName(marketCoinName);
+    spoolIndexer.coinPrice = coinPrices?.[coinName2] || spoolIndexer.coinPrice;
+    spoolIndexer.marketCoinPrice = (coinPrices?.[coinName2] ?? 0) * (marketPool ? marketPool.conversionRate : 0) || spoolIndexer.marketCoinPrice;
+    spoolIndexer.rewardCoinPrice = coinPrices?.[rewardCoinName2] || spoolIndexer.rewardCoinPrice;
+    return spoolIndexer;
+  }
+  const spoolObjectResponse = await query.cache.queryGetObjects(
+    [poolId, rewardPoolId],
+    {
+      showContent: true
+    }
+  );
+  if (!(spoolObjectResponse[0] && spoolObjectResponse[1])) {
+    throw new Error("Fail to fetch spoolObjectResponse!");
+  }
+  const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
+  coinPrices = coinPrices || await query.utils.getCoinPrices([coinName, rewardCoinName]);
+  const spoolObject = spoolObjectResponse[0];
+  const rewardPoolObject = spoolObjectResponse[1];
+  if (spoolObject.content && "fields" in spoolObject.content) {
+    const spoolFields = spoolObject.content.fields;
+    const parsedSpoolData = parseOriginSpoolData({
+      stakeType: spoolFields.stake_type,
+      maxDistributedPoint: spoolFields.max_distributed_point,
+      distributedPoint: spoolFields.distributed_point,
+      distributedPointPerPeriod: spoolFields.distributed_point_per_period,
+      pointDistributionTime: spoolFields.point_distribution_time,
+      maxStake: spoolFields.max_stakes,
+      stakes: spoolFields.stakes,
+      index: spoolFields.index,
+      createdAt: spoolFields.created_at,
+      lastUpdate: spoolFields.last_update
+    });
+    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 rewardPoolFields = rewardPoolObject.content.fields;
+      const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData({
+        claimed_rewards: rewardPoolFields.claimed_rewards,
+        exchange_rate_numerator: rewardPoolFields.exchange_rate_numerator,
+        exchange_rate_denominator: rewardPoolFields.exchange_rate_denominator,
+        rewards: rewardPoolFields.rewards,
+        spool_id: rewardPoolFields.spool_id
+      });
+      const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+      const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+      const calculatedRewardPoolData = calculateSpoolRewardPoolData(
+        parsedSpoolData,
+        parsedSpoolRewardPoolData,
+        calculatedSpoolData,
+        rewardCoinPrice,
+        rewardCoinDecimal
       );
-      if (depositedAmount.isGreaterThan(0)) {
-        totalDepositedPools++;
-      }
-      collaterals[assetCoinName] = {
-        coinName: assetCoinName,
-        coinType: query.utils.parseCoinType(assetCoinName),
-        symbol: query.utils.parseSymbol(assetCoinName),
-        coinDecimal,
-        coinPrice,
-        depositedAmount: depositedAmount.toNumber(),
-        depositedCoin: depositedCoin.toNumber(),
-        depositedValue: depositedValue.toNumber(),
-        borrowCapacityValue: borrowCapacityValue.toNumber(),
-        requiredCollateralValue: requiredCollateralValue2.toNumber(),
-        availableDepositAmount: availableDepositAmount.toNumber(),
-        availableDepositCoin: availableDepositCoin.toNumber(),
-        availableWithdrawAmount: 0,
-        availableWithdrawCoin: 0
+      spool = {
+        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),
+        sCoinType: marketPool.sCoinType,
+        coinDecimal: query.utils.getCoinDecimal(coinName),
+        rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoinName),
+        coinPrice: coinPrices?.[coinName] ?? 0,
+        marketCoinPrice,
+        rewardCoinPrice,
+        maxPoint: parsedSpoolData.maxPoint,
+        distributedPoint: parsedSpoolData.distributedPoint,
+        maxStake: parsedSpoolData.maxStake,
+        ...calculatedSpoolData,
+        exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
+        exchangeRateDenominator: parsedSpoolRewardPoolData.exchangeRateDenominator,
+        ...calculatedRewardPoolData
       };
     }
   }
-  const borrowAssetCoinNames = [
-    .../* @__PURE__ */ new Set([...Object.values(market.pools).map((pool) => pool.coinName)])
-  ];
-  for (const assetCoinName of borrowAssetCoinNames) {
-    const debt = obligationQuery?.debts.find((debt2) => {
-      const poolCoinName = query.utils.parseCoinNameFromType(
-        debt2.type.name
-      );
-      return assetCoinName === poolCoinName;
+  return spool;
+};
+var getStakeAccounts = async ({
+  utils
+}, ownerAddress) => {
+  const owner = ownerAddress || utils.suiKit.currentAddress();
+  const spoolObjectId = utils.address.get("spool.object");
+  const stakeAccountType = `${spoolObjectId}::spool_account::SpoolAccount`;
+  const stakeObjectsResponse = [];
+  let hasNextPage = false;
+  let nextCursor = null;
+  do {
+    const paginatedStakeObjectsResponse = await utils.cache.queryGetOwnedObjects({
+      owner,
+      filter: { StructType: stakeAccountType },
+      options: {
+        showContent: true,
+        showType: true
+      },
+      cursor: nextCursor,
+      limit: 10
     });
-    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_bignumber4.default)(debt?.amount ?? 0).multipliedBy(
-        increasedRate + 1
-      );
-      const borrowedCoin = borrowedAmount.shiftedBy(-1 * coinDecimal);
-      const requiredRepayAmount = borrowedAmount;
-      const requiredRepayCoin = requiredRepayAmount.shiftedBy(-1 * coinDecimal);
-      const availableRepayAmount = (0, import_bignumber4.default)(coinAmount);
-      const availableRepayCoin = availableRepayAmount.shiftedBy(
-        -1 * coinDecimal
-      );
-      const borrowedValue = requiredRepayCoin.multipliedBy(coinPrice);
-      const borrowedValueWithWeight = borrowedValue.multipliedBy(
-        marketPool.borrowWeight
-      );
-      totalBorrowedValue = totalBorrowedValue.plus(borrowedValue);
-      totalBorrowedValueWithWeight = totalBorrowedValueWithWeight.plus(
-        borrowedValueWithWeight
-      );
-      if (borrowedAmount.isGreaterThan(0)) {
-        totalBorrowedPools++;
-      }
-      debts[assetCoinName] = {
-        coinName: assetCoinName,
-        coinType: query.utils.parseCoinType(assetCoinName),
-        symbol: query.utils.parseSymbol(assetCoinName),
-        coinDecimal,
-        coinPrice,
-        borrowedAmount: borrowedAmount.toNumber(),
-        borrowedCoin: borrowedCoin.toNumber(),
-        borrowedValue: borrowedValue.toNumber(),
-        borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
-        borrowIndex: Number(debt?.borrowIndex ?? 0),
-        requiredRepayAmount: requiredRepayAmount.toNumber(),
-        requiredRepayCoin: requiredRepayCoin.toNumber(),
-        availableBorrowAmount: 0,
-        availableBorrowCoin: 0,
-        availableRepayAmount: availableRepayAmount.toNumber(),
-        availableRepayCoin: availableRepayCoin.toNumber()
+    if (!paginatedStakeObjectsResponse)
+      continue;
+    stakeObjectsResponse.push(...paginatedStakeObjectsResponse.data);
+    if (paginatedStakeObjectsResponse.hasNextPage && paginatedStakeObjectsResponse.nextCursor) {
+      hasNextPage = true;
+      nextCursor = paginatedStakeObjectsResponse.nextCursor;
+    } else {
+      hasNextPage = false;
+    }
+  } while (hasNextPage);
+  const stakeAccounts = SUPPORT_SPOOLS.reduce(
+    (acc, stakeName) => {
+      acc[stakeName] = [];
+      return acc;
+    },
+    {}
+  );
+  const stakeMarketCoinTypes = Object.keys(stakeAccounts).reduce(
+    (types, stakeMarketCoinName) => {
+      const stakeCoinName = utils.parseCoinName(stakeMarketCoinName);
+      const marketCoinType = utils.parseMarketCoinType(stakeCoinName);
+      types[stakeMarketCoinName] = `${spoolObjectId}::spool_account::SpoolAccount<${marketCoinType}>`;
+      return types;
+    },
+    {}
+  );
+  const reversedStakeMarketCoinTypes = Object.entries(stakeMarketCoinTypes).reduce(
+    (reversedTypes, [key, value]) => {
+      reversedTypes[value] = key;
+      return reversedTypes;
+    },
+    {}
+  );
+  for (const stakeObject of stakeObjectsResponse.map((ref) => ref.data)) {
+    const id = stakeObject?.objectId;
+    const type = stakeObject?.type;
+    if (id && stakeObject?.content && "fields" in stakeObject.content) {
+      const fields = stakeObject.content.fields;
+      const stakePoolId = String(fields.spool_id);
+      const stakeType = String(fields.stake_type.fields.name);
+      const staked = Number(fields.stakes);
+      const index = Number(fields.index);
+      const points = Number(fields.points);
+      const totalPoints = Number(fields.total_points);
+      const stakeMarketCoinTypeMap = {
+        sweth: stakeAccounts.sweth,
+        ssui: stakeAccounts.ssui,
+        swusdc: stakeAccounts.swusdc,
+        swusdt: stakeAccounts.swusdt,
+        scetus: stakeAccounts.scetus,
+        safsui: stakeAccounts.safsui,
+        shasui: stakeAccounts.shasui,
+        svsui: stakeAccounts.svsui,
+        susdc: stakeAccounts.susdc
       };
+      const normalizedType = (0, import_utils8.normalizeStructTag)(type);
+      const stakeAccountArray = stakeMarketCoinTypeMap[reversedStakeMarketCoinTypes[normalizedType]];
+      if (stakeAccountArray) {
+        stakeAccountArray.push({
+          id,
+          type: normalizedType,
+          stakePoolId,
+          stakeType: (0, import_utils8.normalizeStructTag)(stakeType),
+          staked,
+          index,
+          points,
+          totalPoints
+        });
+      }
     }
   }
-  for (const [poolCoinName, borrowIncentiveAccount] of Object.entries(
-    borrowIncentiveAccounts
-  )) {
-    const coinName = poolCoinName;
-    const borrowIncentivePool = borrowIncentivePools[coinName];
-    if (borrowIncentivePool) {
-      const rewards = [];
-      for (const rewardCoinName of SUPPORT_BORROW_INCENTIVE_REWARDS) {
-        const accountPoint = borrowIncentiveAccount.pointList[rewardCoinName];
-        const poolPoint = borrowIncentivePool.points[rewardCoinName];
-        if (accountPoint && poolPoint) {
-          let availableClaimAmount = (0, import_bignumber4.default)(0);
-          let availableClaimCoin = (0, import_bignumber4.default)(0);
-          const accountBorrowedAmount = (0, import_bignumber4.default)(accountPoint.weightedAmount);
-          const baseIndexRate = 1e9;
-          const increasedPointRate = poolPoint.currentPointIndex ? Math.max(
-            (0, import_bignumber4.default)(poolPoint.currentPointIndex - accountPoint.index).dividedBy(baseIndexRate).toNumber(),
-            0
-          ) : 1;
-          availableClaimAmount = availableClaimAmount.plus(
-            accountBorrowedAmount.multipliedBy(increasedPointRate).plus(accountPoint.points)
-          );
-          availableClaimCoin = availableClaimAmount.shiftedBy(
-            -1 * poolPoint.coinDecimal
-          );
-          const weightScale = (0, import_bignumber4.default)(1e12);
-          const boostValue = (0, import_bignumber4.default)(accountPoint.weightedAmount).div(
-            (0, import_bignumber4.default)(borrowIncentiveAccount.debtAmount).multipliedBy(poolPoint.baseWeight).dividedBy(weightScale)
-          ).isFinite() ? (0, import_bignumber4.default)(accountPoint.weightedAmount).div(
-            (0, import_bignumber4.default)(borrowIncentiveAccount.debtAmount).multipliedBy(poolPoint.baseWeight).dividedBy(weightScale)
-          ).toNumber() : 1;
-          if (availableClaimAmount.isGreaterThanOrEqualTo(0)) {
-            rewards.push({
-              coinName: poolPoint.coinName,
-              coinType: poolPoint.coinType,
-              symbol: poolPoint.symbol,
-              coinDecimal: poolPoint.coinDecimal,
-              coinPrice: poolPoint.coinPrice,
-              availableClaimAmount: availableClaimAmount.toNumber(),
-              availableClaimCoin: availableClaimCoin.toNumber(),
-              boostValue
-            });
-          }
-        }
-      }
-      if (Object.keys(borrowIncentivePool.points).some((coinName2) => {
-        const rewardApr = borrowIncentivePool.points[coinName2]?.rewardApr;
-        return rewardApr !== Infinity && typeof rewardApr == "number" && rewardApr > 0;
-      }) && borrowIncentiveAccount.debtAmount > 0) {
-        totalRewardedPools++;
-      }
-      borrowIncentives[coinName] = {
-        coinName: borrowIncentivePool.coinName,
-        coinType: borrowIncentivePool.coinType,
-        symbol: borrowIncentivePool.symbol,
-        coinDecimal: borrowIncentivePool.coinDecimal,
-        coinPrice: borrowIncentivePool.coinPrice,
-        rewards
+  return stakeAccounts;
+};
+var getStakePool = async ({
+  utils
+}, marketCoinName) => {
+  const poolId = utils.address.get(`spool.pools.${marketCoinName}.id`);
+  let stakePool = void 0;
+  const stakePoolObjectResponse = await utils.cache.queryGetObject(poolId, {
+    showContent: true,
+    showType: true
+  });
+  if (stakePoolObjectResponse?.data) {
+    const stakePoolObject = stakePoolObjectResponse.data;
+    const id = stakePoolObject.objectId;
+    const type = stakePoolObject.type;
+    if (stakePoolObject.content && "fields" in stakePoolObject.content) {
+      const fields = stakePoolObject.content.fields;
+      const maxPoint = Number(fields.max_distributed_point);
+      const distributedPoint = Number(fields.distributed_point);
+      const pointPerPeriod = Number(fields.distributed_point_per_period);
+      const period = Number(fields.point_distribution_time);
+      const maxStake = Number(fields.max_stakes);
+      const stakeType = String(fields.stake_type.fields.name);
+      const totalStaked = Number(fields.stakes);
+      const index = Number(fields.index);
+      const createdAt = Number(fields.created_at);
+      const lastUpdate = Number(fields.last_update);
+      stakePool = {
+        id,
+        type: (0, import_utils8.normalizeStructTag)(type),
+        maxPoint,
+        distributedPoint,
+        pointPerPeriod,
+        period,
+        maxStake,
+        stakeType: (0, import_utils8.normalizeStructTag)(stakeType),
+        totalStaked,
+        index,
+        createdAt,
+        lastUpdate
       };
     }
   }
-  let riskLevel = totalRequiredCollateralValue.isZero() ? (0, import_bignumber4.default)(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
-  riskLevel = riskLevel.isLessThan(1) ? riskLevel : (0, import_bignumber4.default)(1);
-  const accountBalanceValue = totalDepositedValue.minus(totalBorrowedValue).isGreaterThan(0) ? totalDepositedValue.minus(totalBorrowedValue) : (0, import_bignumber4.default)(0);
-  const availableCollateralValue = totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight).isGreaterThan(0) ? totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight) : (0, import_bignumber4.default)(0);
-  const requiredCollateralValue = totalBorrowedValueWithWeight.isGreaterThan(0) ? totalRequiredCollateralValue : (0, import_bignumber4.default)(0);
-  const unhealthyCollateralValue = totalBorrowedValueWithWeight.minus(requiredCollateralValue).isGreaterThan(0) ? totalBorrowedValueWithWeight.minus(requiredCollateralValue) : (0, import_bignumber4.default)(0);
-  const obligationAccount = {
-    obligationId,
-    // Deposited collateral value (collateral balance)
-    totalDepositedValue: totalDepositedValue.toNumber(),
-    // Borrowed debt value (liabilities balance)
-    totalBorrowedValue: totalBorrowedValue.toNumber(),
-    // The difference between the user’s actual deposit and loan (remaining balance)
-    totalBalanceValue: accountBalanceValue.toNumber(),
-    // Effective collateral value (the actual collateral value included in the calculation).
-    totalBorrowCapacityValue: totalBorrowCapacityValue.toNumber(),
-    // Available collateral value (the remaining collateral value that can be borrowed).
-    totalAvailableCollateralValue: availableCollateralValue.toNumber(),
-    // Available debt value (the actual borrowing value included in the calculation).
-    totalBorrowedValueWithWeight: totalBorrowedValueWithWeight.toNumber(),
-    // Required collateral value (avoid be liquidated).
-    totalRequiredCollateralValue: requiredCollateralValue.toNumber(),
-    // Unliquidated collateral value (pending liquidation).
-    totalUnhealthyCollateralValue: unhealthyCollateralValue.toNumber(),
-    totalRiskLevel: riskLevel.toNumber(),
-    totalDepositedPools,
-    totalBorrowedPools,
-    totalRewardedPools,
-    collaterals,
-    debts,
-    borrowIncentives
-  };
-  for (const [collateralCoinName, obligationCollateral] of Object.entries(
-    obligationAccount.collaterals
-  )) {
-    const marketCollateral = market.collaterals[collateralCoinName];
-    if (marketCollateral) {
-      let estimatedAvailableWithdrawAmount = (0, import_bignumber4.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_bignumber4.default)(obligationCollateral.depositedAmount)
-      ) : minBigNumber(
-        estimatedAvailableWithdrawAmount.multipliedBy(
-          estimatedFactor(
-            (0, import_bignumber4.default)(obligationAccount.totalAvailableCollateralValue).dividedBy(marketCollateral.collateralFactor).toNumber(),
-            3,
-            "increase"
-          )
-        ).toNumber(),
-        obligationCollateral.depositedAmount,
-        marketCollateral.depositAmount
-      );
-      obligationCollateral.availableWithdrawAmount = estimatedAvailableWithdrawAmount.toNumber();
-      obligationCollateral.availableWithdrawCoin = estimatedAvailableWithdrawAmount.shiftedBy(-1 * obligationCollateral.coinDecimal).toNumber();
+  return stakePool;
+};
+var getStakeRewardPool = async ({
+  utils
+}, marketCoinName) => {
+  const poolId = utils.address.get(
+    `spool.pools.${marketCoinName}.rewardPoolId`
+  );
+  let stakeRewardPool = void 0;
+  const stakeRewardPoolObjectResponse = await utils.cache.queryGetObject(
+    poolId,
+    {
+      showContent: true,
+      showType: true
     }
-  }
-  for (const [poolCoinName, obligationDebt] of Object.entries(
-    obligationAccount.debts
-  )) {
-    const marketPool = market.pools[poolCoinName];
-    if (marketPool) {
-      const estimatedRequiredRepayAmount = (0, import_bignumber4.default)(
-        obligationDebt.requiredRepayAmount
-      ).multipliedBy(
-        estimatedFactor(obligationDebt.borrowedValue, 3, "decrease")
+  );
+  if (stakeRewardPoolObjectResponse?.data) {
+    const stakeRewardPoolObject = stakeRewardPoolObjectResponse.data;
+    const id = stakeRewardPoolObject.objectId;
+    const type = stakeRewardPoolObject.type;
+    if (stakeRewardPoolObject.content && "fields" in stakeRewardPoolObject.content) {
+      const rewardPoolFields = stakeRewardPoolObject.content.fields;
+      const stakePoolId = String(rewardPoolFields.spool_id);
+      const ratioNumerator = Number(rewardPoolFields.exchange_rate_numerator);
+      const ratioDenominator = Number(
+        rewardPoolFields.exchange_rate_denominator
       );
-      let estimatedAvailableBorrowAmount = (0, import_bignumber4.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"
-          )
-        ).toNumber(),
-        marketPool.supplyAmount
-      ) : (0, import_bignumber4.default)(0);
-      obligationDebt.availableBorrowAmount = estimatedAvailableBorrowAmount.toNumber();
-      obligationDebt.availableBorrowCoin = estimatedAvailableBorrowAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
-      obligationDebt.requiredRepayAmount = estimatedRequiredRepayAmount.toNumber();
-      obligationDebt.requiredRepayCoin = estimatedRequiredRepayAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
+      const rewards = Number(rewardPoolFields.rewards);
+      const claimedRewards = Number(rewardPoolFields.claimed_rewards);
+      stakeRewardPool = {
+        id,
+        type: (0, import_utils8.normalizeStructTag)(type),
+        stakePoolId,
+        ratioNumerator,
+        ratioDenominator,
+        rewards,
+        claimedRewards
+      };
     }
   }
-  return obligationAccount;
-};
-var getTotalValueLocked = async (query, indexer = false) => {
-  const market = await query.queryMarket(indexer);
-  let supplyValue = (0, import_bignumber4.default)(0);
-  let borrowValue = (0, import_bignumber4.default)(0);
-  if (indexer) {
-    const tvlIndexer = await query.indexer.getTotalValueLocked();
-    const tvl2 = {
-      supplyValue: tvlIndexer.supplyValue,
-      supplyValueChangeRatio: tvlIndexer.supplyValueChangeRatio,
-      borrowValue: tvlIndexer.borrowValue,
-      borrowValueChangeRatio: tvlIndexer.borrowValueChangeRatio,
-      totalValue: tvlIndexer.totalValue,
-      totalValueChangeRatio: tvlIndexer.totalValueChangeRatio
-    };
-    return tvl2;
-  }
-  for (const pool of Object.values(market.pools)) {
-    supplyValue = supplyValue.plus(
-      (0, import_bignumber4.default)(pool.supplyCoin).multipliedBy(pool.coinPrice)
-    );
-    borrowValue = borrowValue.plus(
-      (0, import_bignumber4.default)(pool.borrowCoin).multipliedBy(pool.coinPrice)
-    );
-  }
-  for (const collateral of Object.values(market.collaterals)) {
-    supplyValue = supplyValue.plus(
-      (0, import_bignumber4.default)(collateral.depositCoin).multipliedBy(collateral.coinPrice)
-    );
-  }
-  const tvl = {
-    supplyValue: supplyValue.toNumber(),
-    borrowValue: borrowValue.toNumber(),
-    totalValue: supplyValue.minus(borrowValue).toNumber()
-  };
-  return tvl;
+  return stakeRewardPool;
 };
 
 // src/queries/vescaQuery.ts
-var import_bignumber5 = __toESM(require("bignumber.js"));
+var import_bignumber7 = __toESM(require("bignumber.js"));
 var import_sui_kit3 = require("@scallop-io/sui-kit");
-var import_bcs = require("@mysten/sui/bcs");
-var import_zod2 = require("zod");
-var import_assert = __toESM(require("assert"));
+var import_bcs2 = require("@mysten/sui/bcs");
+var import_zod4 = require("zod");
+var import_assert2 = __toESM(require("assert"));
 var getVescaKeys = async (utils, ownerAddress) => {
   const owner = ownerAddress || utils.suiKit.currentAddress();
   const veScaObjId = utils.address.get("vesca.object");
@@ -4292,10 +4550,10 @@ var getVeScas = async ({
   }
   return result;
 };
-var SuiObjectRefZod = import_zod2.z.object({
-  objectId: import_zod2.z.string(),
-  digest: import_zod2.z.string(),
-  version: import_zod2.z.string()
+var SuiObjectRefZod = import_zod4.z.object({
+  objectId: import_zod4.z.string(),
+  digest: import_zod4.z.string(),
+  version: import_zod4.z.string()
 });
 var getVeSca = async (utils, veScaKey) => {
   const tableId = utils.address.get(`vesca.tableId`);
@@ -4322,7 +4580,7 @@ var getVeSca = async (utils, veScaKey) => {
       0
     );
     const lockedScaAmount = String(dynamicFields.locked_sca_amount);
-    const lockedScaCoin = (0, import_bignumber5.default)(dynamicFields.locked_sca_amount).shiftedBy(-9).toNumber();
+    const lockedScaCoin = (0, import_bignumber7.default)(dynamicFields.locked_sca_amount).shiftedBy(-9).toNumber();
     const currentVeScaBalance = lockedScaCoin * (Math.floor(remainingLockPeriodInMilliseconds / 1e3) / MAX_LOCK_DURATION);
     vesca = {
       id: veScaDynamicFieldObject.objectId,
@@ -4332,7 +4590,7 @@ var getVeSca = async (utils, veScaKey) => {
       lockedScaAmount,
       lockedScaCoin,
       currentVeScaBalance,
-      unlockAt: (0, import_bignumber5.default)(dynamicFields.unlock_at * 1e3).toNumber()
+      unlockAt: (0, import_bignumber7.default)(dynamicFields.unlock_at * 1e3).toNumber()
     };
   }
   return vesca;
@@ -4381,8 +4639,8 @@ var getTotalVeScaTreasuryAmount = async (utils, veScaTreasury) => {
   if (results && results[1]?.returnValues) {
     const value = Uint8Array.from(results[1].returnValues[0][0]);
     const type = results[1].returnValues[0][1];
-    (0, import_assert.default)(type === "u64", "Result type is not u64");
-    return import_bcs.bcs.u64().parse(value);
+    (0, import_assert2.default)(type === "u64", "Result type is not u64");
+    return import_bcs2.bcs.u64().parse(value);
   }
   return "0";
 };
@@ -4394,10 +4652,10 @@ var getVeScaTreasuryInfo = async (utils) => {
   if (!veScaTreasury || veScaTreasury.data?.content?.dataType !== "moveObject")
     return null;
   const treasuryFields = veScaTreasury.data.content.fields;
-  const totalLockedSca = (0, import_bignumber5.default)(
+  const totalLockedSca = (0, import_bignumber7.default)(
     treasuryFields.unlock_schedule.fields.locked_sca_amount
   ).shiftedBy(-9).toNumber();
-  const totalVeSca = (0, import_bignumber5.default)(
+  const totalVeSca = (0, import_bignumber7.default)(
     await getTotalVeScaTreasuryAmount(utils, veScaTreasury.data) ?? 0
   ).shiftedBy(-9).toNumber();
   const averageLockingPeriod = totalLockedSca > 0 ? totalVeSca / totalLockedSca * 4 : 0;
@@ -4410,94 +4668,8 @@ var getVeScaTreasuryInfo = async (utils) => {
   };
 };
 
-// src/queries/referralQuery.ts
-var queryVeScaKeyIdFromReferralBindings = async (address, refereeAddress) => {
-  const referralBindingTableId = address.get("referral.bindingTableId");
-  const referralBindResponse = await address.cache.queryGetDynamicFieldObject({
-    parentId: referralBindingTableId,
-    name: {
-      type: "address",
-      value: refereeAddress
-    }
-  });
-  if (referralBindResponse?.data?.content?.dataType !== "moveObject")
-    return null;
-  const fields = referralBindResponse.data.content.fields;
-  return fields.value;
-};
-
-// src/queries/loyaltyProgramQuery.ts
-var import_bignumber6 = __toESM(require("bignumber.js"));
-var import_zod3 = require("zod");
-var rewardPoolFieldsZod = import_zod3.z.object({
-  balance: import_zod3.z.string(),
-  enable_claim: import_zod3.z.boolean()
-}).transform((value) => ({
-  totalPoolReward: (0, import_bignumber6.default)(value.balance).shiftedBy(-9).toNumber(),
-  isClaimEnabled: value.enable_claim
-}));
-var userRewardFieldsZod = import_zod3.z.object({
-  value: import_zod3.z.string()
-}).transform((value) => (0, import_bignumber6.default)(value.value).shiftedBy(-9).toNumber());
-var getLoyaltyProgramInformations = async (query, veScaKey) => {
-  const rewardPool = query.address.get("loyaltyProgram.rewardPool");
-  const rewardPoolObject = await query.cache.queryGetObject(rewardPool, {
-    showContent: true
-  });
-  if (rewardPoolObject?.data?.content?.dataType !== "moveObject")
-    return null;
-  const rewardPoolFields = rewardPoolObject.data.content.fields;
-  const { isClaimEnabled, totalPoolReward } = rewardPoolFieldsZod.parse(
-    rewardPoolFields
-  );
-  const result = {
-    pendingReward: 0,
-    totalPoolReward,
-    isClaimEnabled
-  };
-  veScaKey = veScaKey ?? (await query.getVeScas())[0]?.keyObject;
-  if (!veScaKey)
-    return result;
-  const userRewardTableId = query.address.get(
-    "loyaltyProgram.userRewardTableId"
-  );
-  const userRewardObject = await query.cache.queryGetDynamicFieldObject({
-    parentId: userRewardTableId,
-    name: {
-      type: "0x2::object::ID",
-      value: typeof veScaKey === "string" ? veScaKey : veScaKey.objectId
-    }
-  });
-  if (userRewardObject?.data?.content?.dataType !== "moveObject")
-    return result;
-  const userRewardFields = userRewardObject.data.content.fields;
-  result.pendingReward = userRewardFieldsZod.parse(
-    userRewardFields
-  );
-  return result;
-};
-
 // src/models/suiKit.ts
 var import_sui_kit4 = require("@scallop-io/sui-kit");
-
-// src/constants/rpc.ts
-var import_client = require("@mysten/sui/client");
-var RPC_PROVIDERS = [
-  (0, import_client.getFullnodeUrl)("mainnet"),
-  "https://sui-mainnet.public.blastapi.io",
-  "https://sui-mainnet-ca-2.cosmostation.io",
-  "https://sui-mainnet-eu-4.cosmostation.io",
-  "https://sui-mainnet-endpoint.blockvision.org",
-  "https://sui-rpc.publicnode.com",
-  "https://sui-mainnet-rpc.allthatnode.com",
-  "https://mainnet.suiet.app",
-  "https://mainnet.sui.rpcpool.com",
-  "https://sui1mainnet-rpc.chainode.tech",
-  "https://fullnode.mainnet.apis.scallop.io",
-  "https://sui-mainnet-us-2.cosmostation.io"
-];
-
-// src/models/suiKit.ts
 var newSuiKit = (params) => {
   return new import_sui_kit4.SuiKit({
     ...params,
@@ -6754,183 +6926,8 @@ var ScallopIndexer = class {
   }
 };
 
-// src/queries/sCoinQuery.ts
-var import_bcs2 = require("@mysten/sui/bcs");
-var import_assert2 = __toESM(require("assert"));
-var import_bignumber7 = __toESM(require("bignumber.js"));
-var getSCoinTotalSupply = async ({
-  utils
-}, sCoinName) => {
-  const sCoinPkgId = utils.address.get("scoin.id");
-  const args = [utils.getSCoinTreasury(sCoinName)];
-  const typeArgs = [
-    utils.parseSCoinType(sCoinName),
-    utils.parseUnderlyingSCoinType(sCoinName)
-  ];
-  const queryTarget = `${sCoinPkgId}::s_coin_converter::total_supply`;
-  const queryResults = await utils.cache.queryInspectTxn({
-    queryTarget,
-    args,
-    typeArgs
-  });
-  const results = queryResults?.results;
-  if (results && results[0]?.returnValues) {
-    const value = Uint8Array.from(results[0].returnValues[0][0]);
-    const type = results[0].returnValues[0][1];
-    (0, import_assert2.default)(type === "u64", "Result type is not u64");
-    return (0, import_bignumber7.default)(import_bcs2.bcs.u64().parse(value)).shiftedBy(utils.getCoinDecimal(utils.parseCoinName(sCoinName))).toNumber();
-  }
-  return 0;
-};
-var getSCoinAmounts = async ({
-  utils
-}, sCoinNames = [...SUPPORT_SCOIN], ownerAddress) => {
-  const owner = ownerAddress || utils.suiKit.currentAddress();
-  const sCoins2 = {};
-  await Promise.allSettled(
-    sCoinNames.map(async (sCoinName) => {
-      const sCoin = await getSCoinAmount({ utils }, sCoinName, owner);
-      sCoins2[sCoinName] = sCoin;
-    })
-  );
-  return sCoins2;
-};
-var getSCoinAmount = async ({
-  utils
-}, sCoinName, ownerAddress) => {
-  const owner = ownerAddress || utils.suiKit.currentAddress();
-  const sCoinType = utils.parseSCoinType(sCoinName);
-  const amount = await utils.cache.queryGetCoinBalance({
-    owner,
-    coinType: sCoinType
-  });
-  return (0, import_bignumber7.default)(amount).toNumber();
-};
-var isSupportStakeCoins = (value) => {
-  return SUPPORT_SCOIN.includes(value);
-};
-var checkAssetParams = (fromSCoin, toSCoin) => {
-  if (fromSCoin === toSCoin)
-    throw new Error("fromAsset and toAsset must be different");
-  if (!isSupportStakeCoins(fromSCoin))
-    throw new Error("fromAsset is not supported");
-  if (!isSupportStakeCoins(toSCoin)) {
-    throw new Error("toAsset is not supported");
-  }
-};
-var getSCoinSwapRate = async (query, fromSCoin, toSCoin, underlyingCoinPrice) => {
-  checkAssetParams(fromSCoin, toSCoin);
-  const fromCoinName = query.utils.parseCoinName(fromSCoin);
-  const toCoinName = query.utils.parseCoinName(toSCoin);
-  const marketPools = await Promise.all([
-    query.getMarketPool(fromCoinName, false),
-    query.getMarketPool(toCoinName, false)
-  ]);
-  if (marketPools.some((pool) => !pool))
-    throw new Error("Failed to fetch the lendings data");
-  if (marketPools.some((pool) => pool?.conversionRate === 0)) {
-    throw new Error("Conversion rate cannot be zero");
-  }
-  const ScoinAToARate = marketPools[0].conversionRate;
-  const BtoSCoinBRate = 1 / marketPools[1].conversionRate;
-  const calcAtoBRate = async () => {
-    const prices = await query.utils.getCoinPrices([fromCoinName, toCoinName]);
-    if (!prices[fromCoinName] || !prices[toCoinName]) {
-      throw new Error("Failed to fetch the coin prices");
-    }
-    if (prices[toCoinName] === 0) {
-      throw new Error("Price of toCoin cannot be zero");
-    }
-    return prices[fromCoinName] / prices[toCoinName];
-  };
-  const AtoBRate = underlyingCoinPrice ?? await calcAtoBRate();
-  return (0, import_bignumber7.default)(ScoinAToARate).multipliedBy(AtoBRate).multipliedBy(BtoSCoinBRate).toNumber();
-};
-
 // src/models/scallopQuery.ts
 var import_utils23 = require("@mysten/sui/utils");
-
-// src/queries/isolatedAsset.ts
-var import_zod4 = require("zod");
-var isolatedAssetZod = import_zod4.z.object({
-  dataType: import_zod4.z.string(),
-  type: import_zod4.z.string(),
-  hasPublicTransfer: import_zod4.z.boolean(),
-  fields: import_zod4.z.object({
-    id: import_zod4.z.object({
-      id: import_zod4.z.string()
-    }),
-    name: import_zod4.z.object({
-      type: import_zod4.z.string()
-    }),
-    value: import_zod4.z.boolean()
-  })
-});
-var ISOLATED_ASSET_KEY = "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::IsolatedAssetKey";
-var getIsolatedAssets = async (address) => {
-  try {
-    const marketObject = address.get("core.market");
-    const isolatedAssets = [];
-    if (!marketObject)
-      return isolatedAssets;
-    let hasNextPage = false;
-    let nextCursor = null;
-    const isIsolatedDynamicField = (dynamicField) => {
-      return dynamicField.name.type === ISOLATED_ASSET_KEY;
-    };
-    do {
-      const response = await address.cache.queryGetDynamicFields({
-        parentId: marketObject,
-        cursor: nextCursor,
-        limit: 10
-      });
-      if (!response)
-        break;
-      const isolatedAssetCoinTypes = response.data.filter(isIsolatedDynamicField).map(({ name }) => `0x${name.value.type.name}`);
-      isolatedAssets.push(...isolatedAssetCoinTypes);
-      if (response && response.hasNextPage && response.nextCursor) {
-        hasNextPage = true;
-        nextCursor = response.nextCursor;
-      } else {
-        hasNextPage = false;
-      }
-    } while (hasNextPage);
-    return isolatedAssets;
-  } catch (e) {
-    console.error(e);
-    return [];
-  }
-};
-var isIsolatedAsset = async (utils, coinName) => {
-  try {
-    const marketObject = utils.address.get("core.market");
-    const cachedData = utils.address.cache.queryClient.getQueryData([
-      "getDynamicFields",
-      marketObject
-    ]);
-    if (cachedData) {
-      const coinType2 = utils.parseCoinType(coinName);
-      return cachedData.includes(coinType2);
-    }
-    const coinType = utils.parseCoinType(coinName).slice(2);
-    const object = await utils.cache.queryGetDynamicFieldObject({
-      parentId: marketObject,
-      name: {
-        type: ISOLATED_ASSET_KEY,
-        value: coinType
-      }
-    });
-    const parsedData = isolatedAssetZod.safeParse(object?.data?.content);
-    if (!parsedData.success)
-      return false;
-    return parsedData.data.fields.value;
-  } catch (e) {
-    console.error(e);
-    return false;
-  }
-};
-
-// src/models/scallopQuery.ts
 var ScallopQuery = class {
   constructor(params, instance) {
     this.params = params;
@@ -8447,6 +8444,7 @@ var Scallop = class {
   PROTOCOL_OBJECT_ID,
   PYTH_ENDPOINTS,
   PYTH_FEED_IDS,
+  RPC_PROVIDERS,
   SCA_COIN_TYPE,
   SDK_API_BASE_URL,
   SUPPORT_BORROW_INCENTIVE_POOLS,