@gearbox-protocol/sdk 13.0.0-beta.1 → 13.0.0-beta.2

package/dist/cjs/sdk/utils/index.js

@@ -18,9 +18,12 @@ module.exports = __toCommonJS(utils_exports);
 __reExport(utils_exports, require("./AddressMap.js"), module.exports);
 __reExport(utils_exports, require("./AddressSet.js"), module.exports);
 __reExport(utils_exports, require("./abi-decode.js"), module.exports);
+__reExport(utils_exports, require("./assetsMath.js"), module.exports);
+__reExport(utils_exports, require("./bigintMath.js"), module.exports);
 __reExport(utils_exports, require("./bytes32ToString.js"), module.exports);
 __reExport(utils_exports, require("./childLogger.js"), module.exports);
 __reExport(utils_exports, require("./createRawTx.js"), module.exports);
+__reExport(utils_exports, require("./creditAccount.js"), module.exports);
 __reExport(utils_exports, require("./etherscan.js"), module.exports);
 __reExport(utils_exports, require("./filterDust.js"), module.exports);
 __reExport(utils_exports, require("./formatter.js"), module.exports);
@@ -28,6 +31,7 @@ __reExport(utils_exports, require("./hex.js"), module.exports);
 __reExport(utils_exports, require("./isDust.js"), module.exports);
 __reExport(utils_exports, require("./json.js"), module.exports);
 __reExport(utils_exports, require("./mappers.js"), module.exports);
+__reExport(utils_exports, require("./priceMath.js"), module.exports);
 __reExport(utils_exports, require("./retry.js"), module.exports);
 __reExport(utils_exports, require("./toAddress.js"), module.exports);
 __reExport(utils_exports, require("./type-utils.js"), module.exports);
@@ -37,9 +41,12 @@ __reExport(utils_exports, require("./zod.js"), module.exports);
   ...require("./AddressMap.js"),
   ...require("./AddressSet.js"),
   ...require("./abi-decode.js"),
+  ...require("./assetsMath.js"),
+  ...require("./bigintMath.js"),
   ...require("./bytes32ToString.js"),
   ...require("./childLogger.js"),
   ...require("./createRawTx.js"),
+  ...require("./creditAccount.js"),
   ...require("./etherscan.js"),
   ...require("./filterDust.js"),
   ...require("./formatter.js"),
@@ -47,6 +54,7 @@ __reExport(utils_exports, require("./zod.js"), module.exports);
   ...require("./isDust.js"),
   ...require("./json.js"),
   ...require("./mappers.js"),
+  ...require("./priceMath.js"),
   ...require("./retry.js"),
   ...require("./toAddress.js"),
   ...require("./type-utils.js"),

package/dist/cjs/sdk/utils/priceMath.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var priceMath_exports = {};
+__export(priceMath_exports, {
+  PriceUtils: () => PriceUtils
+});
+module.exports = __toCommonJS(priceMath_exports);
+var import__ = require("../index.js");
+class PriceUtils {
+  static calcTotalPrice = (price, amount, decimals = 18) => amount * import__.WAD * price / 10n ** BigInt(decimals) / import__.PRICE_DECIMALS;
+  static convertByPrice(totalMoney, { price: targetPrice, decimals: targetDecimals = 18 }) {
+    if (targetPrice <= 0n) return 0n;
+    return totalMoney * 10n ** BigInt(targetDecimals) * import__.PRICE_DECIMALS / targetPrice / import__.WAD;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PriceUtils
+});

package/dist/esm/sdk/utils/assetsMath.js

@@ -0,0 +1,125 @@
+import { BigIntMath, PriceUtils } from "../index.js";
+import { CreditAccountDataUtils } from "./creditAccount.js";
+class AssetUtils {
+  static nextAsset({
+    allowedTokens,
+    selectedAssets,
+    balances,
+    tokensList,
+    prices = {}
+  }) {
+    const selectedRecord = selectedAssets.reduce(
+      (acc, { token }) => {
+        acc[token.toLowerCase()] = true;
+        return acc;
+      },
+      {}
+    );
+    const notSelected = allowedTokens.filter((allowedToken) => {
+      const alreadySelected = selectedRecord[allowedToken.toLowerCase()];
+      return !alreadySelected;
+    });
+    const sorted = CreditAccountDataUtils.sortBalances(
+      AssetUtils.getBalances(notSelected, balances),
+      prices,
+      tokensList
+    );
+    const [address] = sorted[0] || [];
+    return address;
+  }
+  static getBalances(allowedTokens, externalBalances) {
+    return allowedTokens.reduce((acc, address) => {
+      const addressLc = address.toLowerCase();
+      return {
+        ...acc,
+        [addressLc]: externalBalances[addressLc] || 0n
+      };
+    }, {});
+  }
+  static constructAssetRecord(a) {
+    const record = a.reduce((acc, asset) => {
+      acc[asset.token] = asset;
+      return acc;
+    }, {});
+    return record;
+  }
+  static memoWrap = (unwrappedAddress, wrappedAddress, prices, tokensList) => function wrap(assets) {
+    const assetsRecord = AssetUtils.constructAssetRecord(assets);
+    const unwrapped = assetsRecord[unwrappedAddress];
+    const wrapped = assetsRecord[wrappedAddress];
+    const { balance: wrappedAmount = 0n } = wrapped || {};
+    if (unwrapped) {
+      const { balance: unwrappedAmount = 0n } = unwrapped || {};
+      const unwrappedToken = tokensList[unwrappedAddress];
+      const unwrappedPrice = prices[unwrappedAddress] || 0n;
+      const wrappedToken = tokensList[wrappedAddress];
+      const wrappedPrice = prices[wrappedAddress] || 0n;
+      const unwrappedInWrapped = PriceUtils.convertByPrice(
+        PriceUtils.calcTotalPrice(
+          unwrappedPrice,
+          BigIntMath.max(0n, unwrappedAmount),
+          unwrappedToken.decimals
+        ),
+        {
+          price: wrappedPrice,
+          decimals: wrappedToken.decimals
+        }
+      );
+      assetsRecord[wrappedAddress] = {
+        token: wrappedAddress,
+        balance: BigIntMath.max(0n, wrappedAmount) + unwrappedInWrapped
+      };
+      delete assetsRecord[unwrappedAddress];
+      return [Object.values(assetsRecord), unwrappedInWrapped, wrappedAmount];
+    }
+    return [Object.values(assetsRecord), 0n, wrappedAmount];
+  };
+  /**
+   * Sums the the second assets list into the first assets list
+   * Balances cant be negative; creates new assets.
+   */
+  static sumAssets(a, b) {
+    const aRecord = AssetUtils.constructAssetRecord(a);
+    const resRecord = b.reduce((acc, bAsset) => {
+      const aAsset = acc[bAsset.token];
+      const { balance: amount = 0n } = aAsset || {};
+      const amountSum = BigIntMath.max(0n, bAsset.balance) + BigIntMath.max(0n, amount);
+      const aOrB = aAsset || bAsset;
+      acc[bAsset.token] = {
+        ...aOrB,
+        balance: amountSum
+      };
+      return acc;
+    }, aRecord);
+    return Object.values(resRecord);
+  }
+  /**
+   * Sums the the second assets list into the first assets list
+   * Balances cant be negative; doesn't create new assets.
+   */
+  static addBalances(a, b) {
+    const bRecord = AssetUtils.constructAssetRecord(b);
+    return a.map((asset) => {
+      const bAsset = bRecord[asset.token];
+      const { balance: bAmount = 0n } = bAsset || {};
+      const amountSum = BigIntMath.max(0n, asset.balance) + BigIntMath.max(0n, bAmount);
+      return { ...asset, balance: amountSum };
+    });
+  }
+  /**
+   * Subtracts the the second assets list from the first assets list
+   * Balances cant be negative; doesn't create new assets.
+   */
+  static subAssets(a, b) {
+    const bRecord = AssetUtils.constructAssetRecord(b);
+    return a.map((asset) => {
+      const bAsset = bRecord[asset.token];
+      const { balance: bAmount = 0n } = bAsset || {};
+      const amountSub = BigIntMath.max(0n, asset.balance) - BigIntMath.max(0n, bAmount);
+      return { ...asset, balance: BigIntMath.max(0n, amountSub) };
+    });
+  }
+}
+export {
+  AssetUtils
+};

package/dist/esm/sdk/utils/bigintMath.js

@@ -0,0 +1,9 @@
+class BigIntMath {
+  static abs = (x) => x < 0n ? -x : x;
+  static max = (a, b) => a > b ? a : b;
+  static min = (a, b) => a < b ? a : b;
+  static neg = (a) => a > 0 ? a * -1n : a;
+}
+export {
+  BigIntMath
+};

package/dist/esm/sdk/utils/creditAccount.js

@@ -0,0 +1,394 @@
+import {
+  BigIntMath,
+  MIN_INT96,
+  PERCENTAGE_DECIMALS,
+  PERCENTAGE_FACTOR,
+  PRICE_DECIMALS,
+  PRICE_DECIMALS_POW,
+  PriceUtils,
+  SECONDS_PER_YEAR,
+  WAD,
+  WAD_DECIMALS_POW
+} from "../index.js";
+const MAX_UINT16 = 65535;
+class CreditAccountDataUtils {
+  static sortBalances(balances, prices, tokens) {
+    return Object.entries(balances).sort(
+      ([addr1, amount1], [addr2, amount2]) => {
+        return CreditAccountDataUtils.assetComparator(
+          {
+            token: addr1,
+            balance: amount1
+          },
+          {
+            token: addr2,
+            balance: amount2
+          },
+          prices,
+          prices,
+          tokens,
+          tokens
+        );
+      }
+    );
+  }
+  static sortAssets(balances, prices, tokens) {
+    return [...balances].sort(
+      (t1, t2) => CreditAccountDataUtils.assetComparator(
+        t1,
+        t2,
+        prices,
+        prices,
+        tokens,
+        tokens
+      )
+    );
+  }
+  static assetComparator(t1, t2, prices1, prices2, tokens1, tokens2) {
+    const addr1Lc = t1.token.toLowerCase();
+    const addr2Lc = t2.token.toLowerCase();
+    const token1 = tokens1?.[addr1Lc];
+    const token2 = tokens2?.[addr2Lc];
+    const price1 = prices1?.[addr1Lc] || PRICE_DECIMALS;
+    const price2 = prices2?.[addr2Lc] || PRICE_DECIMALS;
+    const totalPrice1 = PriceUtils.calcTotalPrice(
+      price1,
+      t1.balance,
+      token1?.decimals
+    );
+    const totalPrice2 = PriceUtils.calcTotalPrice(
+      price2,
+      t2.balance,
+      token2?.decimals
+    );
+    if (totalPrice1 === totalPrice2) {
+      return t1.balance === t2.balance ? CreditAccountDataUtils.tokensAbcComparator(token1, token2) : CreditAccountDataUtils.amountAbcComparator(t1.balance, t2.balance);
+    }
+    return CreditAccountDataUtils.amountAbcComparator(totalPrice1, totalPrice2);
+  }
+  static tokensAbcComparator(t1, t2) {
+    const { symbol: symbol1 = "" } = t1 || {};
+    const { symbol: symbol2 = "" } = t2 || {};
+    const symbol1LC = symbol1.toLowerCase();
+    const symbol2LC = symbol2.toLowerCase();
+    if (symbol1LC === symbol2LC) return 0;
+    return symbol1LC > symbol2LC ? 1 : -1;
+  }
+  static amountAbcComparator(t1, t2) {
+    return t1 > t2 ? -1 : 1;
+  }
+  static calcMaxDebtIncrease(healthFactor, debt, underlyingLT, minHf = Number(PERCENTAGE_FACTOR)) {
+    const result = debt * BigInt(healthFactor - minHf) / BigInt(minHf - underlyingLT);
+    return BigIntMath.max(0n, result);
+  }
+  static calcMaxLendingDebt({
+    assets,
+    liquidationThresholds,
+    underlyingToken,
+    prices,
+    tokensList,
+    targetHF = PERCENTAGE_FACTOR
+  }) {
+    const assetsLTMoney = assets.reduce(
+      (acc, { token: tokenAddress, balance: amount }) => {
+        const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
+        const lt = liquidationThresholds[tokenAddress] || 0n;
+        const price = prices[tokenAddress] || 0n;
+        const tokenMoney = PriceUtils.calcTotalPrice(
+          price,
+          amount,
+          tokenDecimals
+        );
+        const tokenLtMoney = tokenMoney * lt;
+        return acc + tokenLtMoney;
+      },
+      0n
+    );
+    const underlyingPrice = prices[underlyingToken] || 0n;
+    const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
+    const max = underlyingPrice > 0 ? assetsLTMoney * 10n ** BigInt(underlyingDecimals) / underlyingPrice / targetHF / 10n ** BigInt(WAD_DECIMALS_POW - PRICE_DECIMALS_POW) : 0n;
+    return max;
+  }
+  // [
+  //  Sum(amount_i * price_i * apy_i - quota_i * quotaPrice * quotaRate_i * (1 + feeInterest)) -
+  //  debt * debtPrice * baseRateWithFee
+  // ] / (totalValue - debt) * debtPrice
+  static calcOverallAPY({
+    caAssets,
+    lpAPY,
+    prices,
+    quotas,
+    quotaRates,
+    feeInterest,
+    totalValue,
+    debt,
+    baseRateWithFee,
+    underlyingToken,
+    tokensList
+  }) {
+    if (!lpAPY || !totalValue || totalValue <= 0n || !debt || totalValue <= debt)
+      return void 0;
+    const underlyingTokenDecimals = tokensList[underlyingToken]?.decimals || 18;
+    const underlyingPrice = prices[underlyingToken];
+    const assetAPYMoney = caAssets.reduce(
+      (acc, { token: tokenAddress, balance: amount }) => {
+        const apy = lpAPY[tokenAddress] || 0;
+        const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
+        const price = prices[tokenAddress] || 0n;
+        const money = PriceUtils.calcTotalPrice(price, amount, tokenDecimals);
+        const apyMoney = money * BigInt(apy);
+        const { rate: quotaAPY = 0n, isActive = false } = quotaRates?.[tokenAddress] || {};
+        const { balance: quotaBalance = 0n } = quotas[tokenAddress] || {};
+        const quotaAmount = isActive ? quotaBalance : 0n;
+        const quotaMoney = PriceUtils.calcTotalPrice(
+          underlyingPrice || 0n,
+          quotaAmount,
+          underlyingTokenDecimals
+        );
+        const quotaRate = quotaAPY * (BigInt(feeInterest) + PERCENTAGE_FACTOR) / PERCENTAGE_FACTOR;
+        const quotaAPYMoney = quotaMoney * quotaRate;
+        return acc + apyMoney - quotaAPYMoney;
+      },
+      0n
+    );
+    const debtMoney = PriceUtils.calcTotalPrice(
+      underlyingPrice || 0n,
+      debt,
+      underlyingTokenDecimals
+    );
+    const debtAPYMoney = debtMoney * BigInt(baseRateWithFee);
+    const yourAssetsMoney = PriceUtils.calcTotalPrice(
+      underlyingPrice || PRICE_DECIMALS,
+      totalValue - debt,
+      underlyingTokenDecimals
+    );
+    const apyInPercent = (assetAPYMoney - debtAPYMoney) / yourAssetsMoney;
+    return apyInPercent;
+  }
+  static calcHealthFactor({
+    assets,
+    quotas,
+    quotasInfo,
+    liquidationThresholds,
+    underlyingToken,
+    debt,
+    prices,
+    tokensList
+  }) {
+    if (debt === 0n) return MAX_UINT16;
+    const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
+    const underlyingPrice = prices[underlyingToken] || 0n;
+    const assetMoney = assets.reduce(
+      (acc, { token: tokenAddress, balance: amount }) => {
+        const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
+        const lt = liquidationThresholds[tokenAddress] || 0n;
+        const price = prices[tokenAddress] || 0n;
+        const tokenMoney = PriceUtils.calcTotalPrice(
+          price,
+          amount,
+          tokenDecimals
+        );
+        const tokenLtMoney = tokenMoney * lt / PERCENTAGE_FACTOR;
+        const { isActive = false } = quotasInfo?.[tokenAddress] || {};
+        const quota = quotas[tokenAddress];
+        const quotaBalance = isActive ? quota?.balance || 0n : 0n;
+        const quotaMoney = PriceUtils.calcTotalPrice(
+          underlyingPrice,
+          quotaBalance,
+          underlyingDecimals
+        );
+        const money = quota ? BigIntMath.min(quotaMoney, tokenLtMoney) : tokenLtMoney;
+        return acc + money;
+      },
+      0n
+    );
+    const borrowedMoney = PriceUtils.calcTotalPrice(
+      underlyingPrice || PRICE_DECIMALS,
+      debt,
+      underlyingDecimals
+    );
+    const hfInPercent = borrowedMoney > 0n ? assetMoney * PERCENTAGE_FACTOR / borrowedMoney : 0n;
+    return Number(hfInPercent);
+  }
+  static roundUpQuota(quotaChange) {
+    return quotaChange !== MIN_INT96 ? quotaChange / PERCENTAGE_FACTOR * PERCENTAGE_FACTOR : quotaChange;
+  }
+  static calcRecommendedQuota({
+    amount,
+    debt,
+    lt,
+    quotaReserve
+  }) {
+    const recommendedBaseQuota = BigIntMath.min(
+      debt,
+      amount * lt / PERCENTAGE_FACTOR
+    );
+    const recommendedQuota = recommendedBaseQuota * (PERCENTAGE_FACTOR + quotaReserve) / PERCENTAGE_FACTOR;
+    return CreditAccountDataUtils.roundUpQuota(recommendedQuota);
+  }
+  static calcDefaultQuota({ amount, lt, quotaReserve }) {
+    const recommendedBaseQuota = amount * lt / PERCENTAGE_FACTOR;
+    const recommendedQuota = recommendedBaseQuota * (PERCENTAGE_FACTOR + quotaReserve) / PERCENTAGE_FACTOR;
+    return CreditAccountDataUtils.roundUpQuota(recommendedQuota);
+  }
+  static calcQuotaUpdate(props) {
+    const { quotas, initialQuotas, maxDebt, allowedToSpend, allowedToObtain } = props;
+    const quotaDecrease = Object.keys(allowedToSpend).reduce((acc, token) => {
+      const ch = CreditAccountDataUtils.getSingleQuotaChange(
+        token,
+        0n,
+        props
+      );
+      if (ch && ch.balance < 0) acc[ch.token] = ch;
+      return acc;
+    }, {});
+    const quotaCap = CreditAccountDataUtils.roundUpQuota(maxDebt * 2n);
+    const quotaBought = Object.values(initialQuotas).reduce(
+      (sum, q) => sum + CreditAccountDataUtils.roundUpQuota(q?.quota || 0n),
+      0n
+    );
+    const quotaReduced = Object.values(quotaDecrease).reduce((sum, q) => {
+      const quotaBalance = q.balance || 0n;
+      const safeBalance = quotaBalance === MIN_INT96 ? BigIntMath.neg(
+        CreditAccountDataUtils.roundUpQuota(
+          initialQuotas[q.token]?.quota || 0n
+        )
+      ) : quotaBalance;
+      return sum + safeBalance;
+    }, 0n);
+    const maxQuotaIncrease = CreditAccountDataUtils.roundUpQuota(
+      BigIntMath.max(quotaCap - (quotaBought + quotaReduced), 0n)
+    );
+    const quotaIncrease = Object.keys(allowedToObtain).reduce((acc, token) => {
+      const ch = CreditAccountDataUtils.getSingleQuotaChange(
+        token,
+        maxQuotaIncrease,
+        props
+      );
+      if (ch && ch.balance > 0) acc[ch.token] = ch;
+      return acc;
+    }, {});
+    const quotaChange = {
+      ...quotaDecrease,
+      ...quotaIncrease
+    };
+    const desiredQuota = Object.values(quotas).reduce(
+      (acc, cmQuota) => {
+        const { token, isActive } = cmQuota;
+        const { quota: initialQuota = 0n } = initialQuotas[token] || {};
+        if (!isActive) {
+          acc[token] = {
+            balance: initialQuota,
+            token
+          };
+        } else {
+          const change = quotaChange[token]?.balance || 0n;
+          const quotaAfter = change === MIN_INT96 ? 0n : initialQuota + change;
+          acc[token] = {
+            balance: quotaAfter,
+            token
+          };
+        }
+        return acc;
+      },
+      {}
+    );
+    return {
+      desiredQuota,
+      quotaDecrease: Object.values(quotaDecrease),
+      quotaIncrease: Object.values(quotaIncrease)
+    };
+  }
+  static getSingleQuotaChange(token, unsafeMaxQuotaIncrease, props) {
+    const { isActive = false } = props.quotas[token] || {};
+    const { quota: unsafeInitialQuota = 0n } = props.initialQuotas[token] || {};
+    if (!isActive) {
+      return void 0;
+    }
+    const assetAfter = props.assetsAfterUpdate[token];
+    const { amountInTarget = 0n } = assetAfter || {};
+    const lt = props.liquidationThresholds[token] || 0n;
+    const maxQuotaIncrease = CreditAccountDataUtils.roundUpQuota(
+      unsafeMaxQuotaIncrease
+    );
+    const initialQuota = CreditAccountDataUtils.roundUpQuota(unsafeInitialQuota);
+    const defaultQuota = props.calcModification?.type === "recommendedQuota" && props.calcModification.debt > 0 ? CreditAccountDataUtils.calcRecommendedQuota({
+      lt,
+      quotaReserve: props.quotaReserve,
+      amount: amountInTarget,
+      debt: props.calcModification.debt
+    }) : CreditAccountDataUtils.calcDefaultQuota({
+      lt,
+      quotaReserve: props.quotaReserve,
+      amount: amountInTarget
+    });
+    const unsafeQuotaChange = CreditAccountDataUtils.roundUpQuota(
+      defaultQuota - initialQuota
+    );
+    const quotaChange = unsafeQuotaChange > 0 ? BigIntMath.min(maxQuotaIncrease, unsafeQuotaChange) : unsafeQuotaChange < 0 && BigIntMath.abs(unsafeQuotaChange) >= initialQuota ? MIN_INT96 : unsafeQuotaChange;
+    const correctIncrease = assetAfter && props.allowedToObtain[token] && quotaChange > 0;
+    const correctDecrease = assetAfter && props.allowedToSpend[token] && quotaChange < 0;
+    if (correctIncrease || correctDecrease) {
+      return {
+        balance: quotaChange,
+        token
+      };
+    }
+    return void 0;
+  }
+  static calcQuotaBorrowRate({ quotas, quotaRates }) {
+    const totalRateBalance = Object.values(quotas).reduce(
+      (acc, { token, balance }) => {
+        const { rate = 0, isActive = false } = quotaRates?.[token] || {};
+        const quotaBalance = isActive ? balance : 0n;
+        const rateBalance = quotaBalance * BigInt(rate);
+        return acc + rateBalance;
+      },
+      0n
+    );
+    return totalRateBalance;
+  }
+  static calcRelativeBaseBorrowRate({
+    debt,
+    baseRateWithFee,
+    assetAmountInUnderlying
+  }) {
+    return debt * BigInt(baseRateWithFee) * assetAmountInUnderlying;
+  }
+  static liquidationPrice({
+    liquidationThresholds,
+    debt,
+    underlyingToken,
+    targetToken,
+    assets,
+    tokensList
+  }) {
+    const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
+    const { balance: underlyingBalance = 0n } = assets[underlyingToken] || {};
+    const ltUnderlying = liquidationThresholds[underlyingToken] || 0n;
+    const effectiveDebt = (debt - underlyingBalance * ltUnderlying / PERCENTAGE_FACTOR) * WAD / 10n ** BigInt(underlyingDecimals);
+    const targetDecimals = tokensList[targetToken]?.decimals || 18;
+    const { balance: targetBalance = 0n } = assets[targetToken] || {};
+    const effectiveTargetBalance = targetBalance * WAD / 10n ** BigInt(targetDecimals);
+    const lpLT = liquidationThresholds[targetToken] || 0n;
+    if (targetBalance <= 0n || lpLT <= 0n) return 0n;
+    return effectiveDebt * PRICE_DECIMALS * PERCENTAGE_FACTOR / (effectiveTargetBalance * lpLT);
+  }
+  /**
+   * Calculates the time remaining until liquidation for a credit account.
+   * @returns The time remaining until liquidation in milliseconds.
+   */
+  static getTimeToLiquidation({
+    healthFactor,
+    totalBorrowRate_debt
+  }) {
+    if (healthFactor <= PERCENTAGE_FACTOR || totalBorrowRate_debt === 0n)
+      return null;
+    const HF_1 = BigInt(healthFactor) - PERCENTAGE_FACTOR;
+    const brPerYear = BigInt(SECONDS_PER_YEAR) * PERCENTAGE_FACTOR * PERCENTAGE_DECIMALS / totalBorrowRate_debt;
+    return HF_1 * brPerYear * 1000n / PERCENTAGE_FACTOR;
+  }
+}
+export {
+  CreditAccountDataUtils
+};

package/dist/esm/sdk/utils/formatter.js

@@ -1,4 +1,6 @@
 import { formatDuration as fmtDuration, intervalToDuration } from "date-fns";
+import Decimal from "decimal.js-light";
+import { LEVERAGE_DECIMALS, PERCENTAGE_FACTOR } from "../index.js";
 const toBigInt = (v) => {
   const value = typeof v === "object" && v.type === "BigNumber" ? v.hex : v.toString();
   return BigInt(value);
@@ -98,14 +100,48 @@ function formatTimestamp(timestamp, raw = true) {
   });
   return raw ? `${result} [${timestamp}]` : result;
 }
+function rayToNumber(num) {
+  return Number(toBigInt(num) / 10n ** 21n) / 1e6;
+}
+function toSignificant(num, decimals, precision = 6) {
+  if (num === 1n) return "0";
+  const divider = new Decimal(10).toPower(decimals);
+  const number = new Decimal(num.toString()).div(divider);
+  return number.toSignificantDigits(precision, 4).toString();
+}
+function toBN(num, decimals) {
+  if (num === "") return 0n;
+  const multiplier = new Decimal(10).toPower(decimals);
+  const number = new Decimal(num).mul(multiplier);
+  return BigInt(number.toFixed(0));
+}
+function shortAddress(address) {
+  return address === void 0 ? "" : `${address.slice(0, 6)}...${address.slice(address.length - 4)}`;
+}
+function shortHash(address) {
+  return address === void 0 ? "" : `${address.slice(0, 5)}...`;
+}
+function formatPercentage(healthFactor, decimals = 2) {
+  return (healthFactor / Number(PERCENTAGE_FACTOR)).toFixed(decimals);
+}
+function formatLeverage(leverage, decimals = 2) {
+  return (leverage / Number(LEVERAGE_DECIMALS)).toFixed(decimals);
+}
 export {
   fmtBinaryMask,
   formatBN,
   formatBNvalue,
   formatDuration,
+  formatLeverage,
   formatNumberToString_,
+  formatPercentage,
   formatTimestamp,
   numberWithCommas,
   percentFmt,
-  toBigInt
+  rayToNumber,
+  shortAddress,
+  shortHash,
+  toBN,
+  toBigInt,
+  toSignificant
 };

package/dist/esm/sdk/utils/index.js

@@ -1,9 +1,12 @@
 export * from "./AddressMap.js";
 export * from "./AddressSet.js";
 export * from "./abi-decode.js";
+export * from "./assetsMath.js";
+export * from "./bigintMath.js";
 export * from "./bytes32ToString.js";
 export * from "./childLogger.js";
 export * from "./createRawTx.js";
+export * from "./creditAccount.js";
 export * from "./etherscan.js";
 export * from "./filterDust.js";
 export * from "./formatter.js";
@@ -11,6 +14,7 @@ export * from "./hex.js";
 export * from "./isDust.js";
 export * from "./json.js";
 export * from "./mappers.js";
+export * from "./priceMath.js";
 export * from "./retry.js";
 export * from "./toAddress.js";
 export * from "./type-utils.js";

package/dist/esm/sdk/utils/priceMath.js

@@ -0,0 +1,11 @@
+import { PRICE_DECIMALS, WAD } from "../index.js";
+class PriceUtils {
+  static calcTotalPrice = (price, amount, decimals = 18) => amount * WAD * price / 10n ** BigInt(decimals) / PRICE_DECIMALS;
+  static convertByPrice(totalMoney, { price: targetPrice, decimals: targetDecimals = 18 }) {
+    if (targetPrice <= 0n) return 0n;
+    return totalMoney * 10n ** BigInt(targetDecimals) * PRICE_DECIMALS / targetPrice / WAD;
+  }
+}
+export {
+  PriceUtils
+};