@scallop-io/sui-scallop-sdk 0.37.4 → 0.37.5

package/dist/index.js

@@ -519,7 +519,7 @@ var ScallopUtils = class {
    * @return The selected transaction coin arguments.
    */
   async selectCoins(owner, amount, coinType = import_sui.SUI_TYPE_ARG) {
-    const coins = await this._suiKit.rpcProvider.selectCoins(
+    const coins = await this._suiKit.suiInteractor.selectCoins(
       owner,
       amount,
       coinType
@@ -605,14 +605,149 @@ var ScallopUtils = class {
 
 // src/queries/market.ts
 var import_sui_kit2 = require("@scallop-io/sui-kit");
-var queryMarket = async (scallopAddress, suiKit) => {
+var import_bignumber = __toESM(require("bignumber.js"));
+var queryMarket = async (scallopAddress, suiKit, scallopUtils) => {
   const packageId = scallopAddress.get("core.packages.query.id");
   const marketId = scallopAddress.get("core.market");
   const txBlock = new import_sui_kit2.SuiTxBlock();
   const queryTarget = `${packageId}::market_query::market_data`;
   txBlock.moveCall(queryTarget, [marketId]);
   const queryResult = await suiKit.inspectTxn(txBlock);
-  return queryResult.events[0].parsedJson;
+  const marketData = queryResult.events[0].parsedJson;
+  const assets = [];
+  const collaterals = [];
+  for (const asset of marketData.pools) {
+    const coinType = "0x" + asset.type.name;
+    const borrowAPYFactor = 24 * 365 * 3600;
+    const baseBorrowRate = Number(asset.baseBorrowRatePerSec.value) / 2 ** 32;
+    const borrowRateOnHighKink = Number(asset.borrowRateOnHighKink.value) / 2 ** 32;
+    const borrowRateOnMidKink = Number(asset.borrowRateOnMidKink.value) / 2 ** 32;
+    const maxBorrowRate = Number(asset.maxBorrowRate.value) / 2 ** 32;
+    const highKink = Number(asset.highKink.value) / 2 ** 32;
+    const midKink = Number(asset.midKink.value) / 2 ** 32;
+    const borrowRate = Number(asset.interestRate.value) / 2 ** 32;
+    const borrowRateScale = Number(asset.interestRateScale);
+    const borrowIndex = Number(asset.borrowIndex);
+    const lastUpdated = Number(asset.lastUpdated);
+    const cash = Number(asset.cash);
+    const debt = Number(asset.debt);
+    const marketCoinSupply = Number(asset.marketCoinSupply);
+    const minBorrowAmount = Number(asset.minBorrowAmount);
+    const reserve = Number(asset.reserve);
+    const reserveFactor = Number(asset.reserveFactor.value) / 2 ** 32;
+    const borrowWeight = Number(asset.borrowWeight.value) / 2 ** 32;
+    const caculatedBaseBorrowRate = (0, import_bignumber.default)(baseBorrowRate).multipliedBy(borrowAPYFactor).dividedBy(borrowRateScale).toNumber();
+    const caculatedBorrowRateOnHighKink = (0, import_bignumber.default)(borrowRateOnHighKink).multipliedBy(borrowAPYFactor).dividedBy(borrowRateScale).toNumber();
+    const caculatedBorrowRateOnMidKink = (0, import_bignumber.default)(borrowRateOnMidKink).multipliedBy(borrowAPYFactor).dividedBy(borrowRateScale).toNumber();
+    const caculatedMaxBorrowRate = (0, import_bignumber.default)(maxBorrowRate).multipliedBy(borrowAPYFactor).dividedBy(borrowRateScale).toNumber();
+    const caculatedBorrowRate = (0, import_bignumber.default)(borrowRate).multipliedBy(borrowAPYFactor).dividedBy(borrowRateScale).toNumber();
+    const timeDelta = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - lastUpdated;
+    const borrowIndexDelta = (0, import_bignumber.default)(borrowIndex).multipliedBy((0, import_bignumber.default)(timeDelta).multipliedBy(borrowRate)).dividedBy(borrowRateScale);
+    const currentBorrowIndex = (0, import_bignumber.default)(borrowIndex).plus(borrowIndexDelta);
+    const growthInterest = (0, import_bignumber.default)(currentBorrowIndex).dividedBy(borrowIndex).minus(1);
+    const increasedDebt = (0, import_bignumber.default)(debt).multipliedBy(growthInterest);
+    const currentTotalDebt = increasedDebt.plus(debt);
+    const currentTotalReserve = (0, import_bignumber.default)(reserve).plus(
+      increasedDebt.multipliedBy(reserveFactor)
+    );
+    const currentTotalSupply = (0, import_bignumber.default)(currentTotalDebt).plus(
+      Math.max(cash - currentTotalReserve.toNumber(), 0)
+    );
+    let utilizationRate = (0, import_bignumber.default)(currentTotalDebt).dividedBy(currentTotalSupply);
+    utilizationRate = utilizationRate.isFinite() ? utilizationRate : (0, import_bignumber.default)(0);
+    let supplyRate = (0, import_bignumber.default)(caculatedBorrowRate).multipliedBy(utilizationRate).multipliedBy(1 - reserveFactor);
+    supplyRate = supplyRate.isFinite() ? supplyRate : (0, import_bignumber.default)(0);
+    const coin = scallopUtils.getCoinNameFromCoinType(
+      coinType
+    );
+    const symbol = coin.toUpperCase();
+    const marketCoinType = scallopUtils.parseMarketCoinType(
+      scallopAddress.get(`core.coins.${coin}.id`),
+      scallopAddress.get("core.packages.protocol.id"),
+      coin
+    );
+    const wrappedType = coin === "usdc" ? {
+      from: "Wormhole",
+      type: "Portal from Ethereum"
+    } : void 0;
+    assets.push({
+      coin,
+      symbol,
+      coinType,
+      wrappedType,
+      marketCoinType,
+      calculated: {
+        utilizationRate: utilizationRate.toNumber(),
+        baseBorrowRate: caculatedBaseBorrowRate,
+        borrowInterestRate: Math.min(
+          caculatedBorrowRate,
+          caculatedMaxBorrowRate
+        ),
+        supplyInterestRate: supplyRate.toNumber(),
+        currentGrowthInterest: growthInterest.toNumber(),
+        currentBorrowIndex: currentBorrowIndex.toNumber(),
+        currentTotalSupply: currentTotalSupply.toNumber(),
+        currentTotalDebt: currentTotalDebt.toNumber(),
+        currentTotalReserve: currentTotalReserve.toNumber()
+      },
+      origin: {
+        highKink,
+        midKink,
+        baseBorrowRate: caculatedBaseBorrowRate,
+        borrowRateOnHighKink: caculatedBorrowRateOnHighKink,
+        borrowRateOnMidKink: caculatedBorrowRateOnMidKink,
+        borrowRate: caculatedBorrowRate,
+        maxBorrowRate: caculatedMaxBorrowRate,
+        reserveFactor,
+        borrowWeight,
+        borrowIndex,
+        lastUpdated,
+        debt,
+        cash,
+        marketCoinSupply,
+        minBorrowAmount,
+        reserve
+      }
+    });
+  }
+  for (const collateral of marketData.collaterals) {
+    const coinType = "0x" + collateral.type.name;
+    const collateralFactor = Number(collateral.collateralFactor.value) / 2 ** 32;
+    const liquidationFactor = Number(collateral.liquidationFactor.value) / 2 ** 32;
+    const liquidationDiscount = Number(collateral.liquidationDiscount.value) / 2 ** 32;
+    const liquidationPanelty = Number(collateral.liquidationPanelty.value) / 2 ** 32;
+    const liquidationReserveFactor = Number(collateral.liquidationReserveFactor.value) / 2 ** 32;
+    const maxCollateralAmount = Number(collateral.maxCollateralAmount);
+    const totalCollateralAmount = Number(collateral.totalCollateralAmount);
+    const coin = scallopUtils.getCoinNameFromCoinType(
+      coinType
+    );
+    const symbol = coin.toUpperCase();
+    const wrappedType = coin === "usdc" ? {
+      from: "Wormhole",
+      type: "Portal from Ethereum"
+    } : void 0;
+    collaterals.push({
+      coin,
+      symbol,
+      coinType,
+      wrappedType,
+      origin: {
+        collateralFactor,
+        liquidationFactor,
+        liquidationDiscount,
+        liquidationPanelty,
+        liquidationReserveFactor,
+        maxCollateralAmount,
+        totalCollateralAmount
+      }
+    });
+  }
+  return {
+    assets,
+    collaterals,
+    data: marketData
+  };
 };
 
 // src/queries/obligation.ts
@@ -1224,7 +1359,7 @@ var ScallopClient = class {
    * @return Market data
    */
   async queryMarket() {
-    return queryMarket(this.address, this.suiKit);
+    return queryMarket(this.address, this.suiKit, this._utils);
   }
   /**
    * Query obligations data.