@scallop-io/sui-scallop-sdk 0.42.6 → 0.42.8

package/dist/index.mjs

@@ -89,6 +89,24 @@ var rewardCoins = {
   susdc: "sui",
   susdt: "sui"
 };
+var coinIds = {
+  sui: "0x0000000000000000000000000000000000000000000000000000000000000002",
+  eth: "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5",
+  btc: "0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881",
+  usdc: "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf",
+  usdt: "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c",
+  apt: "0x3a5143bb1196e3bcdfab6203d1683ae29edd26294fc8bfeafe4aaa9d2704df37",
+  sol: "0xb7844e289a8410e50fb3ca48d69eb9cf29e27d223ef90353fe1bd8e27ff8f3f8",
+  cetus: "0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b"
+};
+var wormholeCoinIds = {
+  eth: "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5",
+  btc: "0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881",
+  usdc: "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf",
+  usdt: "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c",
+  apt: "0x3a5143bb1196e3bcdfab6203d1683ae29edd26294fc8bfeafe4aaa9d2704df37",
+  sol: "0xb7844e289a8410e50fb3ca48d69eb9cf29e27d223ef90353fe1bd8e27ff8f3f8"
+};
 
 // src/models/scallop.ts
 import { SuiKit as SuiKit5 } from "@scallop-io/sui-kit";
@@ -636,12 +654,12 @@ var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
     parsedMarketPoolData.debtAmount
   );
   const borrowCoin = borrowAmount.shiftedBy(-1 * coinDecimal);
-  const teserveAmount = BigNumber(parsedMarketPoolData.reserveAmount).plus(
+  const reserveAmount = BigNumber(parsedMarketPoolData.reserveAmount).plus(
     increasedDebtAmount.multipliedBy(parsedMarketPoolData.reserveFactor)
   );
-  const reserveCoin = teserveAmount.shiftedBy(-1 * coinDecimal);
+  const reserveCoin = reserveAmount.shiftedBy(-1 * coinDecimal);
   const supplyAmount = BigNumber(borrowAmount).plus(
-    Math.max(parsedMarketPoolData.cashAmount - teserveAmount.toNumber(), 0)
+    Math.max(parsedMarketPoolData.cashAmount - reserveAmount.toNumber(), 0)
   );
   const supplyCoin = supplyAmount.shiftedBy(-1 * coinDecimal);
   let utilizationRate = BigNumber(borrowAmount).dividedBy(supplyAmount);
@@ -672,7 +690,7 @@ var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
     supplyCoin: supplyCoin.toNumber(),
     borrowAmount: borrowAmount.toNumber(),
     borrowCoin: borrowCoin.toNumber(),
-    reserveAmount: teserveAmount.toNumber(),
+    reserveAmount: reserveAmount.toNumber(),
     reserveCoin: reserveCoin.toNumber(),
     utilizationRate: utilizationRate.toNumber(),
     supplyApr: supplyApr.toNumber(),
@@ -796,9 +814,9 @@ var calculateRewardPoolData = (parsedStakePoolData, parsedRewardPoolData, calcul
   );
   const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
   const rewardValueForYear = BigNumber(rewardPerSec).shiftedBy(-1 * rewardCoinDecimal).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
-  const stakeRate = rewardValueForYear.dividedBy(calculatedStakePoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedStakePoolData.stakedValue).toNumber() : Infinity;
+  const rewardRate = rewardValueForYear.dividedBy(calculatedStakePoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedStakePoolData.stakedValue).toNumber() : Infinity;
   return {
-    stakeApr: stakeRate,
+    rewardApr: rewardRate,
     totalRewardAmount: totalRewardAmount.toNumber(),
     totalRewardCoin: totalRewardCoin.toNumber(),
     totalRewardValue: totalRewardValue.toNumber(),
@@ -813,6 +831,13 @@ var calculateRewardPoolData = (parsedStakePoolData, parsedRewardPoolData, calcul
     exchangeRateDenominator: parsedRewardPoolData.exchangeRateDenominator
   };
 };
+var minBigNumber = (...args) => {
+  return BigNumber(
+    args.reduce(
+      (min, current) => new BigNumber(current).lt(min) ? current : min
+    )
+  );
+};
 
 // src/utils/util.ts
 var isMarketCoin = (coinName) => {
@@ -873,6 +898,8 @@ var queryMarket = async (query) => {
       coinWrappedType: query.utils.getCoinWrappedType(poolCoinName),
       coinDecimal: query.utils.getCoinDecimal(poolCoinName),
       coinPrice,
+      highKink: parsedMarketPoolData.highKink,
+      midKink: parsedMarketPoolData.midKink,
       reserveFactor: parsedMarketPoolData.reserveFactor,
       borrowWeight: parsedMarketPoolData.borrowWeight,
       marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
@@ -1041,6 +1068,8 @@ var getMarketPool = async (query, poolCoinName, marketObject, coinPrice) => {
       coinWrappedType: query.utils.getCoinWrappedType(poolCoinName),
       coinDecimal: query.utils.getCoinDecimal(poolCoinName),
       coinPrice: coinPrice ?? 0,
+      highKink: parsedMarketPoolData.highKink,
+      midKink: parsedMarketPoolData.midKink,
       reserveFactor: parsedMarketPoolData.reserveFactor,
       borrowWeight: parsedMarketPoolData.borrowWeight,
       marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
@@ -1444,8 +1473,8 @@ var getSpool = async (query, stakeMarketCoinName, marketPool) => {
           rewardCoinDecimal
         );
         spool = {
-          marketCoin: stakeMarketCoinName,
-          symbol: query.utils.parseSymbol(stakeCoinName),
+          marketCoinName: stakeMarketCoinName,
+          symbol: query.utils.parseSymbol(stakeMarketCoinName),
           coinType: query.utils.parseCoinType(stakeCoinName),
           marketCoinType: query.utils.parseMarketCoinType(stakeCoinName),
           rewardCoinType: isMarketCoin(rewardCoin) ? query.utils.parseMarketCoinType(rewardCoin) : query.utils.parseCoinType(rewardCoin),
@@ -1721,7 +1750,9 @@ var getLending = async (query, poolCoinName, ownerAddress, marketPool, spool, st
   let stakedCoin = BigNumber3(0);
   let stakedValue = BigNumber3(0);
   let availableUnstakeAmount = BigNumber3(0);
+  let availableUnstakeCoin = BigNumber3(0);
   let availableClaimAmount = BigNumber3(0);
+  let availableClaimCoin = BigNumber3(0);
   if (spool) {
     for (const stakeAccount of stakeAccounts) {
       const accountStakedMarketCoinAmount = BigNumber3(stakeAccount.staked);
@@ -1747,6 +1778,7 @@ var getLending = async (query, poolCoinName, ownerAddress, marketPool, spool, st
       availableUnstakeAmount = availableUnstakeAmount.plus(
         accountStakedMarketCoinAmount
       );
+      availableUnstakeCoin = availableUnstakeAmount.shiftedBy(-1 * coinDecimal);
       const baseIndexRate = 1e9;
       const increasedPointRate = spool?.currentPointIndex ? BigNumber3(spool.currentPointIndex - stakeAccount.index).dividedBy(
         baseIndexRate
@@ -1754,6 +1786,7 @@ var getLending = async (query, poolCoinName, ownerAddress, marketPool, spool, st
       availableClaimAmount = availableClaimAmount.plus(
         BigNumber3(stakeAccount.staked).multipliedBy(increasedPointRate).plus(stakeAccount.points).multipliedBy(spool.exchangeRateNumerator).dividedBy(spool.exchangeRateDenominator)
       );
+      availableClaimCoin = availableClaimAmount.shiftedBy(-1 * coinDecimal);
     }
   }
   const suppliedAmount = BigNumber3(marketCoinAmount).multipliedBy(
@@ -1761,6 +1794,18 @@ var getLending = async (query, poolCoinName, ownerAddress, marketPool, spool, st
   );
   const suppliedCoin = suppliedAmount.shiftedBy(-1 * coinDecimal);
   const suppliedValue = suppliedCoin.multipliedBy(coinPrice ?? 0);
+  const unstakedMarketAmount = BigNumber3(marketCoinAmount);
+  const unstakedMarketCoin = unstakedMarketAmount.shiftedBy(-1 * coinDecimal);
+  const availableSupplyAmount = BigNumber3(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),
@@ -1770,7 +1815,7 @@ var getLending = async (query, poolCoinName, ownerAddress, marketPool, spool, st
     coinPrice: coinPrice ?? 0,
     supplyApr: marketPool?.supplyApr ?? 0,
     supplyApy: marketPool?.supplyApy ?? 0,
-    rewardApr: spool?.stakeApr ?? 0,
+    rewardApr: spool?.rewardApr ?? 0,
     suppliedAmount: suppliedAmount.plus(stakedAmount).toNumber(),
     suppliedCoin: suppliedCoin.plus(stakedCoin).toNumber(),
     suppliedValue: suppliedValue.plus(stakedValue).toNumber(),
@@ -1779,11 +1824,21 @@ var getLending = async (query, poolCoinName, ownerAddress, marketPool, spool, st
     stakedAmount: stakedAmount.toNumber(),
     stakedCoin: stakedCoin.toNumber(),
     stakedValue: stakedValue.toNumber(),
-    availableSupplyAmount: coinAmount,
-    availableWithdrawAmount: 0,
-    availableStakeAmount: marketCoinAmount,
+    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(),
-    availableClaimAmount: availableClaimAmount.toNumber()
+    availableUnstakeCoin: availableUnstakeCoin.toNumber(),
+    availableClaimAmount: availableClaimAmount.toNumber(),
+    availableClaimCoin: availableClaimCoin.toNumber()
   };
   return lending;
 };
@@ -1820,13 +1875,13 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
   coinAmounts = coinAmounts || await query.getCoinAmounts(assetCoinNames, ownerAddress);
   const collaterals = {};
   const debts = {};
-  let totalCollateralPools = 0;
-  let totalCollateralValue = BigNumber3(0);
+  let totalDepositedPools = 0;
+  let totalDepositedValue = BigNumber3(0);
   let totalBorrowCapacityValue = BigNumber3(0);
   let totalRequiredCollateralValue = BigNumber3(0);
-  let totalDebtPools = 0;
-  let totalDebtValue = BigNumber3(0);
-  let totalDebtValueWithWeight = BigNumber3(0);
+  let totalBorrowedPools = 0;
+  let totalBorrowedValue = BigNumber3(0);
+  let totalBorrowedValueWithWeight = BigNumber3(0);
   for (const collateral of obligationQuery.collaterals) {
     const collateralCoinName = query.utils.parseCoinNameFromType(
       collateral.type.name
@@ -1836,33 +1891,36 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
     const coinPrice = coinPrices?.[collateralCoinName];
     const coinAmount = coinAmounts?.[collateralCoinName] ?? 0;
     if (marketCollateral && coinPrice) {
-      const collateralAmount = BigNumber3(collateral.amount);
-      const collateralCoin = collateralAmount.shiftedBy(-1 * coinDecimal);
-      const collateralValue = collateralCoin.multipliedBy(coinPrice);
-      const borrowCapacityValue = collateralValue.multipliedBy(
+      const depositedAmount = BigNumber3(collateral.amount);
+      const depositedCoin = depositedAmount.shiftedBy(-1 * coinDecimal);
+      const depositedValue = depositedCoin.multipliedBy(coinPrice);
+      const borrowCapacityValue = depositedValue.multipliedBy(
         marketCollateral.collateralFactor
       );
-      const requiredCollateralValue2 = collateralValue.multipliedBy(
+      const requiredCollateralValue2 = depositedValue.multipliedBy(
         marketCollateral.liquidationFactor
       );
       const availableDepositAmount = BigNumber3(coinAmount);
       const availableDepositCoin = availableDepositAmount.shiftedBy(
         -1 * coinDecimal
       );
-      totalCollateralValue = totalCollateralValue.plus(collateralValue);
+      totalDepositedValue = totalDepositedValue.plus(depositedValue);
       totalBorrowCapacityValue = totalBorrowCapacityValue.plus(borrowCapacityValue);
       totalRequiredCollateralValue = totalRequiredCollateralValue.plus(
         requiredCollateralValue2
       );
-      if (collateralAmount.isGreaterThan(0)) {
-        totalCollateralPools++;
+      if (depositedAmount.isGreaterThan(0)) {
+        totalDepositedPools++;
       }
       collaterals[collateralCoinName] = {
         coinName: collateralCoinName,
         coinType: collateral.type.name,
-        collateralAmount: collateralAmount.toNumber(),
-        collateralCoin: collateralCoin.toNumber(),
-        collateralValue: collateralValue.toNumber(),
+        symbol: query.utils.parseSymbol(collateralCoinName),
+        coinDecimal,
+        coinPrice,
+        depositedAmount: depositedAmount.toNumber(),
+        depositedCoin: depositedCoin.toNumber(),
+        depositedValue: depositedValue.toNumber(),
         borrowCapacityValue: borrowCapacityValue.toNumber(),
         requiredCollateralValue: requiredCollateralValue2.toNumber(),
         availableDepositAmount: availableDepositAmount.toNumber(),
@@ -1881,28 +1939,35 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
     const coinPrice = coinPrices?.[poolCoinName];
     if (marketPool && coinPrice) {
       const increasedRate = marketPool.borrowIndex / Number(debt.borrowIndex) - 1;
-      const debtAmount = BigNumber3(debt.amount);
-      const debtCoin = debtAmount.shiftedBy(-1 * coinDecimal);
-      const availableRepayAmount = debtAmount.multipliedBy(increasedRate + 1);
+      const borrowedAmount = BigNumber3(debt.amount);
+      const borrowedCoin = borrowedAmount.shiftedBy(-1 * coinDecimal);
+      const availableRepayAmount = borrowedAmount.multipliedBy(
+        increasedRate + 1
+      );
       const availableRepayCoin = availableRepayAmount.shiftedBy(
         -1 * coinDecimal
       );
-      const debtValue = availableRepayCoin.multipliedBy(coinPrice);
-      const debtValueWithWeight = debtValue.multipliedBy(
+      const borrowedValue = availableRepayCoin.multipliedBy(coinPrice);
+      const borrowedValueWithWeight = borrowedValue.multipliedBy(
         marketPool.borrowWeight
       );
-      totalDebtValue = totalDebtValue.plus(debtValue);
-      totalDebtValueWithWeight = totalDebtValueWithWeight.plus(debtValueWithWeight);
-      if (debtAmount.isGreaterThan(0)) {
-        totalDebtPools++;
+      totalBorrowedValue = totalBorrowedValue.plus(borrowedValue);
+      totalBorrowedValueWithWeight = totalBorrowedValueWithWeight.plus(
+        borrowedValueWithWeight
+      );
+      if (borrowedAmount.isGreaterThan(0)) {
+        totalBorrowedPools++;
       }
       debts[poolCoinName] = {
         coinName: poolCoinName,
         coinType: debt.type.name,
-        debtAmount: debtAmount.toNumber(),
-        debtCoin: debtCoin.toNumber(),
-        debtValue: debtValue.toNumber(),
-        debtValueWithWeight: debtValueWithWeight.toNumber(),
+        symbol: query.utils.parseSymbol(poolCoinName),
+        coinDecimal,
+        coinPrice,
+        borrowedAmount: borrowedAmount.toNumber(),
+        borrowedCoin: borrowedCoin.toNumber(),
+        borrowedValue: borrowedValue.toNumber(),
+        borrowedValueWithWeight: borrowedValueWithWeight.toNumber(),
         borrowIndex: Number(debt.borrowIndex),
         availableBorrowAmount: 0,
         availableBorrowCoin: 0,
@@ -1911,33 +1976,33 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
       };
     }
   }
-  let riskLevel = totalRequiredCollateralValue.isZero() && totalDebtValueWithWeight.isZero() ? BigNumber3(0) : totalDebtValueWithWeight.dividedBy(totalRequiredCollateralValue);
+  let riskLevel = totalRequiredCollateralValue.isZero() && totalBorrowedValueWithWeight.isZero() ? BigNumber3(0) : totalBorrowedValueWithWeight.dividedBy(totalRequiredCollateralValue);
   riskLevel = riskLevel.isFinite() ? riskLevel.isLessThan(1) ? riskLevel : BigNumber3(1) : BigNumber3(1);
-  const accountBalanceValue = totalCollateralValue.minus(totalDebtValue).isGreaterThan(0) ? totalCollateralValue.minus(totalDebtValue) : BigNumber3(0);
-  const availableCollateralValue = totalBorrowCapacityValue.minus(totalDebtValueWithWeight).isGreaterThan(0) ? totalBorrowCapacityValue.minus(totalDebtValueWithWeight) : BigNumber3(0);
-  const requiredCollateralValue = totalDebtValueWithWeight.isGreaterThan(0) ? totalRequiredCollateralValue : BigNumber3(0);
-  const unhealthyCollateralValue = totalDebtValueWithWeight.minus(requiredCollateralValue).isGreaterThan(0) ? totalDebtValueWithWeight.minus(requiredCollateralValue) : BigNumber3(0);
+  const accountBalanceValue = totalDepositedValue.minus(totalBorrowedValue).isGreaterThan(0) ? totalDepositedValue.minus(totalBorrowedValue) : BigNumber3(0);
+  const availableCollateralValue = totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight).isGreaterThan(0) ? totalBorrowCapacityValue.minus(totalBorrowedValueWithWeight) : BigNumber3(0);
+  const requiredCollateralValue = totalBorrowedValueWithWeight.isGreaterThan(0) ? totalRequiredCollateralValue : BigNumber3(0);
+  const unhealthyCollateralValue = totalBorrowedValueWithWeight.minus(requiredCollateralValue).isGreaterThan(0) ? totalBorrowedValueWithWeight.minus(requiredCollateralValue) : BigNumber3(0);
   const obligationAccount = {
     obligationId,
     // Deposited collateral value (collateral balance)
-    totalCollateralValue: totalCollateralValue.toNumber(),
+    totalDepositedValue: totalDepositedValue.toNumber(),
     // Borrowed debt value (liabilities balance)
-    totalDebtValue: totalDebtValue.toNumber(),
+    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).
-    availableCollateralValue: availableCollateralValue.toNumber(),
+    totalAvailableCollateralValue: availableCollateralValue.toNumber(),
     // Available debt value (the actual borrowing value included in the calculation).
-    totalDebtValueWithWeight: totalDebtValueWithWeight.toNumber(),
+    totalBorrowedValueWithWeight: totalBorrowedValueWithWeight.toNumber(),
     // Required collateral value (avoid be liquidated).
-    requiredCollateralValue: requiredCollateralValue.toNumber(),
+    totalRequiredCollateralValue: requiredCollateralValue.toNumber(),
     // Unliquidated collateral value (pending liquidation).
-    unhealthyCollateralValue: unhealthyCollateralValue.toNumber(),
-    riskLevel: riskLevel.toNumber(),
-    totalCollateralPools,
-    totalDebtPools,
+    totalUnhealthyCollateralValue: unhealthyCollateralValue.toNumber(),
+    totalRiskLevel: riskLevel.toNumber(),
+    totalDepositedPools,
+    totalBorrowedPools,
     collaterals,
     debts
   };
@@ -1946,13 +2011,13 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
   )) {
     const marketCollateral = market.collaterals[collateralCoinName];
     if (marketCollateral) {
-      const availableWithdrawAmount = obligationAccount.totalDebtValueWithWeight === 0 ? obligationCollateral.collateralAmount : Math.min(
-        BigNumber3(obligationAccount.availableCollateralValue).dividedBy(marketCollateral.collateralFactor).dividedBy(marketCollateral.coinPrice).multipliedBy(0.99).toNumber(),
-        obligationCollateral.collateralAmount,
+      const availableWithdrawAmount = obligationAccount.totalBorrowedValueWithWeight === 0 ? BigNumber3(obligationCollateral.depositedAmount) : minBigNumber(
+        BigNumber3(obligationAccount.totalAvailableCollateralValue).dividedBy(marketCollateral.collateralFactor).dividedBy(marketCollateral.coinPrice).multipliedBy(0.99).toNumber(),
+        obligationCollateral.depositedAmount,
         marketCollateral.depositAmount
       );
-      obligationCollateral.availableWithdrawAmount = availableWithdrawAmount;
-      obligationCollateral.availableWithdrawCoin = availableWithdrawAmount;
+      obligationCollateral.availableWithdrawAmount = availableWithdrawAmount.toNumber();
+      obligationCollateral.availableWithdrawCoin = availableWithdrawAmount.shiftedBy(-1 * obligationCollateral.coinDecimal).toNumber();
     }
   }
   for (const [assetCoinName, obligationDebt] of Object.entries(
@@ -1962,17 +2027,19 @@ var getObligationAccount = async (query, obligationId, ownerAddress, market, coi
     if (marketPool) {
       const availableRepayAmount = BigNumber3(
         obligationDebt.availableRepayAmount
-      ).multipliedBy(1.01).toNumber();
-      const availableBorrowAmount = obligationAccount.availableCollateralValue !== 0 ? Math.min(
-        BigNumber3(obligationAccount.availableCollateralValue).dividedBy(
+      ).multipliedBy(1.01);
+      const availableBorrowAmount = obligationAccount.totalAvailableCollateralValue !== 0 ? minBigNumber(
+        BigNumber3(obligationAccount.totalAvailableCollateralValue).dividedBy(
           BigNumber3(marketPool.coinPrice).multipliedBy(
             marketPool.borrowWeight
           )
         ).multipliedBy(0.99).toNumber(),
         marketPool.supplyAmount
-      ) : 0;
-      obligationDebt.availableBorrowAmount = availableBorrowAmount;
-      obligationDebt.availableRepayAmount = availableRepayAmount;
+      ) : BigNumber3(0);
+      obligationDebt.availableBorrowAmount = availableBorrowAmount.toNumber();
+      obligationDebt.availableBorrowCoin = availableBorrowAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
+      obligationDebt.availableRepayAmount = availableRepayAmount.toNumber();
+      obligationDebt.availableRepayCoin = availableRepayAmount.shiftedBy(-1 * obligationDebt.coinDecimal).toNumber();
     }
   }
   return obligationAccount;
@@ -2374,16 +2441,19 @@ var ScallopUtils = class {
    */
   parseCoinType(coinName) {
     coinName = isMarketCoin(coinName) ? this.parseCoinName(coinName) : coinName;
-    const coinPackageId = this._address.get(`core.coins.${coinName}.id`);
+    const coinPackageId = this._address.get(`core.coins.${coinName}.id`) ?? coinIds[coinName] ?? void 0;
+    if (!coinPackageId) {
+      throw Error(`Coin ${coinName} is not supported`);
+    }
     if (coinName === "sui")
       return normalizeStructTag2(`${coinPackageId}::sui::SUI`);
     const wormHoleCoinIds = [
-      this._address.get("core.coins.usdc.id"),
-      this._address.get("core.coins.usdt.id"),
-      this._address.get("core.coins.eth.id"),
-      this._address.get("core.coins.btc.id"),
-      this._address.get("core.coins.sol.id"),
-      this._address.get("core.coins.apt.id")
+      this._address.get("core.coins.usdc.id") ?? wormholeCoinIds.usdc,
+      this._address.get("core.coins.usdt.id") ?? wormholeCoinIds.usdt,
+      this._address.get("core.coins.eth.id") ?? wormholeCoinIds.eth,
+      this._address.get("core.coins.btc.id") ?? wormholeCoinIds.btc,
+      this._address.get("core.coins.sol.id") ?? wormholeCoinIds.sol,
+      this._address.get("core.coins.apt.id") ?? wormholeCoinIds.apt
     ];
     if (wormHoleCoinIds.includes(coinPackageId)) {
       return `${coinPackageId}::coin::COIN`;
@@ -2409,12 +2479,12 @@ var ScallopUtils = class {
     const isMarketCoinType = coinType.includes("reserve::MarketCoin");
     coinType = coinTypeMatch?.[1] || coinType;
     const wormHoleCoinTypeMap = {
-      [`${this._address.get("core.coins.usdc.id")}::coin::COIN`]: "usdc",
-      [`${this._address.get("core.coins.usdt.id")}::coin::COIN`]: "usdt",
-      [`${this._address.get("core.coins.eth.id")}::coin::COIN`]: "eth",
-      [`${this._address.get("core.coins.btc.id")}::coin::COIN`]: "btc",
-      [`${this._address.get("core.coins.sol.id")}::coin::COIN`]: "sol",
-      [`${this._address.get("core.coins.apt.id")}::coin::COIN`]: "apt"
+      [`${this._address.get("core.coins.usdc.id") ?? wormholeCoinIds.usdc}::coin::COIN`]: "usdc",
+      [`${this._address.get("core.coins.usdt.id") ?? wormholeCoinIds.usdt}::coin::COIN`]: "usdt",
+      [`${this._address.get("core.coins.eth.id") ?? wormholeCoinIds.eth}::coin::COIN`]: "eth",
+      [`${this._address.get("core.coins.btc.id") ?? wormholeCoinIds.btc}::coin::COIN`]: "btc",
+      [`${this._address.get("core.coins.sol.id") ?? wormholeCoinIds.sol}::coin::COIN`]: "sol",
+      [`${this._address.get("core.coins.apt.id") ?? wormholeCoinIds.apt}::coin::COIN`]: "apt"
     };
     const assetCoinName = wormHoleCoinTypeMap[coinType] || coinType.split("::")[2].toLowerCase();
     return isMarketCoinType ? this.parseMarketCoinName(assetCoinName) : assetCoinName;
@@ -3879,8 +3949,10 @@ export {
   ScallopUtils,
   assetCoins,
   coinDecimals,
+  coinIds,
   marketCoins,
   rewardCoins,
-  stakeMarketCoins
+  stakeMarketCoins,
+  wormholeCoinIds
 };
 //# sourceMappingURL=index.mjs.map