@gearbox-protocol/sdk 14.5.9 → 14.6.0-next.1

package/dist/esm/common-utils/utils/apy/bonus-apy-from-points.js

@@ -0,0 +1,4 @@
+const BONUS_APY_FROM_POINTS = {};
+export {
+  BONUS_APY_FROM_POINTS
+};

package/dist/esm/common-utils/utils/apy/calculate-effective-borrow-rate.js

@@ -0,0 +1,11 @@
+function calculateEffectiveBorrowRate({
+  underlyingTokenAddress,
+  baseRateWithFee = 0,
+  apyList
+}) {
+  const apy = underlyingTokenAddress ? apyList?.[underlyingTokenAddress] || 0 : 0;
+  return apy > 0 ? baseRateWithFee + apy : baseRateWithFee;
+}
+export {
+  calculateEffectiveBorrowRate
+};

package/dist/esm/common-utils/utils/apy/get-complex-apy-list.js

@@ -0,0 +1,21 @@
+import { TypedObjectUtils } from "../../../sdk/index.js";
+function getComplexAPYList(baseAPYList, extraCollateralAPYList, pool) {
+  if (!pool) return baseAPYList;
+  const poolExtraCollateralAPY = extraCollateralAPYList?.[pool];
+  if (!poolExtraCollateralAPY) return baseAPYList;
+  const baseCopy = { ...baseAPYList };
+  TypedObjectUtils.entries(poolExtraCollateralAPY).forEach(
+    ([token, extraAPY]) => {
+      const baseAPY = baseCopy[token];
+      if (extraAPY.type === "relative" && baseAPY !== void 0) {
+        baseCopy[token] = baseAPY + extraAPY.value;
+      } else if (extraAPY.type === "absolute") {
+        baseCopy[token] = extraAPY.value;
+      }
+    }
+  );
+  return baseCopy;
+}
+export {
+  getComplexAPYList
+};

package/dist/esm/common-utils/utils/apy/get-rate-with-fee.js

@@ -0,0 +1,7 @@
+import { PERCENTAGE_FACTOR, toBigInt } from "../../../sdk/index.js";
+function getRateWithFee(rate, feeInterest) {
+  return toBigInt(rate) * (BigInt(feeInterest) + PERCENTAGE_FACTOR) / PERCENTAGE_FACTOR;
+}
+export {
+  getRateWithFee
+};

package/dist/esm/common-utils/utils/apy/get-single-quota-borrow-rate.js

@@ -0,0 +1,9 @@
+import { calcQuotaBorrowRate } from "../creditAccount/calc-quota-borrow-rate.js";
+import { getRateWithFee } from "./get-rate-with-fee.js";
+function getSingleQuotaBorrowRate(props) {
+  const qr = calcQuotaBorrowRate(props);
+  return getRateWithFee(qr, props.feeInterest);
+}
+export {
+  getSingleQuotaBorrowRate
+};

package/dist/esm/common-utils/utils/apy/index.js

@@ -0,0 +1,6 @@
+export * from "./bonus-apy-from-points.js";
+export * from "./calculate-effective-borrow-rate.js";
+export * from "./get-complex-apy-list.js";
+export * from "./get-rate-with-fee.js";
+export * from "./get-single-quota-borrow-rate.js";
+export * from "./max-apy-formula.js";

package/dist/esm/common-utils/utils/apy/max-apy-formula.js

@@ -0,0 +1,16 @@
+import { LEVERAGE_DECIMALS } from "../../../sdk/index.js";
+import { getFactorFromLeverage } from "../strategies/leverage/index.js";
+function maxAPYFormula({
+  apy,
+  leverage,
+  baseRateWithFee,
+  quotaRateWithFee
+}) {
+  const collateralTerm = apy - quotaRateWithFee;
+  const leverageFactor = getFactorFromLeverage(leverage);
+  const debtTerm = (apy - baseRateWithFee - quotaRateWithFee) * Number(leverageFactor) / Number(LEVERAGE_DECIMALS);
+  return collateralTerm + Math.floor(debtTerm);
+}
+export {
+  maxAPYFormula
+};

package/dist/esm/common-utils/utils/index.js

@@ -1,4 +1,6 @@
+export * from "./apy/index.js";
 export * from "./assets-math.js";
 export * from "./bigint-math.js";
 export * from "./creditAccount/index.js";
 export * from "./price-math.js";
+export * from "./strategies/index.js";

package/dist/esm/common-utils/utils/strategies/__test-utils.js

@@ -0,0 +1,65 @@
+const mockToken1 = "0x1111111111111111111111111111111111111111";
+const mockToken2 = "0x2222222222222222222222222222222222222222";
+const mockUnderlyingToken = "0x9999999999999999999999999999999999999999";
+const mockTokenData = {
+  [mockToken1]: { address: mockToken1, decimals: 18, title: "T1" },
+  [mockToken2]: { address: mockToken2, decimals: 18, title: "T2" },
+  [mockUnderlyingToken]: {
+    address: mockUnderlyingToken,
+    decimals: 18,
+    title: "UNDER"
+  }
+};
+function buildQuota(overrides) {
+  return {
+    rate: 0n,
+    quotaIncreaseFee: 0n,
+    totalQuoted: 0n,
+    limit: 0n,
+    isActive: true,
+    ...overrides
+  };
+}
+function buildPool(overrides = {}) {
+  const address = overrides.address ?? "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+  return {
+    address,
+    totalDebtLimit: 0n,
+    totalBorrowed: 0n,
+    ...overrides
+  };
+}
+function buildCreditManager(overrides = {}) {
+  const address = overrides.address ?? "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+  const pool = overrides.pool ?? "0xcccccccccccccccccccccccccccccccccccccccc";
+  const underlyingToken = overrides.underlyingToken ?? mockUnderlyingToken;
+  const quotas = overrides.quotas ?? {};
+  return {
+    address,
+    underlyingToken,
+    pool,
+    chainId: 1,
+    baseBorrowRate: 0,
+    feeInterest: 0,
+    availableToBorrow: 0n,
+    minDebt: 0n,
+    maxDebt: 0n,
+    totalDebt: 0n,
+    totalDebtLimit: 0n,
+    isDegenMode: false,
+    degenNFT: "0x0000000000000000000000000000000000000000",
+    liquidationThresholds: {},
+    quotas,
+    collateralTokens: [],
+    ...overrides
+  };
+}
+export {
+  buildCreditManager,
+  buildPool,
+  buildQuota,
+  mockToken1,
+  mockToken2,
+  mockTokenData,
+  mockUnderlyingToken
+};

package/dist/esm/common-utils/utils/strategies/availability/check-boolean.js

@@ -0,0 +1,9 @@
+function checkBoolean(a, b) {
+  if (a && b) return 0;
+  if (a) return -1;
+  if (b) return 1;
+  return 0;
+}
+export {
+  checkBoolean
+};

package/dist/esm/common-utils/utils/strategies/availability/check-degen-nft.js

@@ -0,0 +1,11 @@
+import { ADDRESS_0X0 } from "../../../../sdk/index.js";
+function checkDegenNFT(creditManager) {
+  const nftAddress = creditManager.isDegenMode ? creditManager.degenNFT : ADDRESS_0X0;
+  return {
+    nftAddress,
+    freeOfNFT: nftAddress === ADDRESS_0X0
+  };
+}
+export {
+  checkDegenNFT
+};

package/dist/esm/common-utils/utils/strategies/availability/index.js

@@ -0,0 +1,4 @@
+export * from "./check-boolean.js";
+export * from "./check-degen-nft.js";
+export * from "./validate-open-account-pool-quota-status.js";
+export * from "./validate-open-account-pool-status.js";

package/dist/esm/common-utils/utils/strategies/availability/validate-open-account-pool-quota-status.js

@@ -0,0 +1,16 @@
+function validateOpenAccountPoolQuotaStatus(targetToken, creditManager, amountToBorrow) {
+  const quota = creditManager.quotas[targetToken];
+  if (quota) {
+    const realLimit = quota.isActive ? quota.limit : 0n;
+    const quotaLeft = realLimit - quota.totalQuoted;
+    if (quotaLeft < amountToBorrow)
+      return {
+        message: "insufficientQuota",
+        token: targetToken
+      };
+  }
+  return null;
+}
+export {
+  validateOpenAccountPoolQuotaStatus
+};

package/dist/esm/common-utils/utils/strategies/availability/validate-open-account-pool-status.js

@@ -0,0 +1,52 @@
+import { BigIntMath } from "../../bigint-math.js";
+import { validateOpenAccountPoolQuotaStatus } from "./validate-open-account-pool-quota-status.js";
+function validateOpenAccountPoolStatus(props) {
+  const { debt, creditManager, pool, targetToken } = props;
+  const effectiveDebt = BigIntMath.max(creditManager.minDebt, debt);
+  const hasDebtLimit = creditManager.totalDebtLimit >= 0n;
+  const debtLimitLeft = BigIntMath.max(
+    creditManager.totalDebtLimit - creditManager.totalDebt,
+    0n
+  );
+  const { totalDebtLimit = 0n, totalBorrowed = 0n } = pool || {};
+  const hasPoolDebtLimit = totalDebtLimit > 0n;
+  const poolDebtLimitLeft = totalDebtLimit - totalBorrowed;
+  const canOpenMinDebt = creditManager.minDebt <= debtLimitLeft && creditManager.minDebt <= poolDebtLimitLeft && creditManager.minDebt <= creditManager.availableToBorrow;
+  const minPositionSize = BigIntMath.min(
+    BigIntMath.min(debtLimitLeft, poolDebtLimitLeft),
+    creditManager.availableToBorrow
+  );
+  if (hasDebtLimit && effectiveDebt > debtLimitLeft) {
+    return {
+      message: "insufficientDebtLimit",
+      amount: debtLimitLeft,
+      solutionAmount: canOpenMinDebt ? minPositionSize : void 0
+    };
+  }
+  if (hasPoolDebtLimit && effectiveDebt > poolDebtLimitLeft) {
+    return {
+      message: "insufficientPoolDebtLimit",
+      amount: poolDebtLimitLeft,
+      solutionAmount: canOpenMinDebt ? minPositionSize : void 0
+    };
+  }
+  if (effectiveDebt > creditManager.availableToBorrow) {
+    return {
+      message: "insufficientPoolLiquidity",
+      amount: creditManager.availableToBorrow,
+      solutionAmount: canOpenMinDebt ? minPositionSize : void 0
+    };
+  }
+  if (targetToken !== null) {
+    const quotaError = validateOpenAccountPoolQuotaStatus(
+      targetToken,
+      creditManager,
+      effectiveDebt
+    );
+    if (quotaError) return quotaError;
+  }
+  return null;
+}
+export {
+  validateOpenAccountPoolStatus
+};

package/dist/esm/common-utils/utils/strategies/index.js

@@ -0,0 +1,4 @@
+export * from "./availability/index.js";
+export * from "./leverage/index.js";
+export * from "./sort-strategy-cms-by-availability/index.js";
+export * from "./strategy-info/index.js";

package/dist/esm/common-utils/utils/strategies/leverage/calculate-loss-coefficient.js

@@ -0,0 +1,7 @@
+import { SLIPPAGE_DECIMALS, toBigInt } from "../../../../sdk/index.js";
+function calculateLossCoefficient(slippage, constantLoss = 30n) {
+  return 100n * SLIPPAGE_DECIMALS - toBigInt(slippage) - constantLoss;
+}
+export {
+  calculateLossCoefficient
+};

package/dist/esm/common-utils/utils/strategies/leverage/calculate-max-leverage-factor.js

@@ -0,0 +1,21 @@
+import { PERCENTAGE_FACTOR } from "../../../../sdk/index.js";
+import { BigIntMath } from "../../bigint-math.js";
+import { calculateLossCoefficient } from "./calculate-loss-coefficient.js";
+import { maxLeverage } from "./max-leverage.js";
+const DEFAULT_LEVERAGE_CONSTANT_LOSS = 500n;
+function calculateMaxLeverageFactor({
+  targetToken,
+  slippage,
+  creditManagers,
+  constantLoss = DEFAULT_LEVERAGE_CONSTANT_LOSS,
+  leverageLimit
+}) {
+  const maxPossibleLeverage = maxLeverage(targetToken, creditManagers);
+  const coefficient = calculateLossCoefficient(slippage, constantLoss);
+  const maxLeverageValue = BigInt(maxPossibleLeverage) * coefficient / PERCENTAGE_FACTOR;
+  const r = leverageLimit !== void 0 ? BigIntMath.min(BigInt(leverageLimit), maxLeverageValue) : maxLeverageValue;
+  return r;
+}
+export {
+  calculateMaxLeverageFactor
+};

package/dist/esm/common-utils/utils/strategies/leverage/get-factor-from-leverage.js

@@ -0,0 +1,7 @@
+import { LEVERAGE_DECIMALS } from "../../../../sdk/index.js";
+function getFactorFromLeverage(leverage) {
+  return leverage - LEVERAGE_DECIMALS;
+}
+export {
+  getFactorFromLeverage
+};

package/dist/esm/common-utils/utils/strategies/leverage/get-leverage-from-factor.js

@@ -0,0 +1,7 @@
+import { LEVERAGE_DECIMALS } from "../../../../sdk/index.js";
+function getLeverageFromFactor(factor) {
+  return factor + LEVERAGE_DECIMALS;
+}
+export {
+  getLeverageFromFactor
+};

package/dist/esm/common-utils/utils/strategies/leverage/index.js

@@ -0,0 +1,6 @@
+export * from "./calculate-loss-coefficient.js";
+export * from "./calculate-max-leverage-factor.js";
+export * from "./get-factor-from-leverage.js";
+export * from "./get-leverage-from-factor.js";
+export * from "./max-leverage.js";
+export * from "./max-leverage-threshold.js";

package/dist/esm/common-utils/utils/strategies/leverage/max-leverage-threshold.js

@@ -0,0 +1,18 @@
+const EMPTY_ADDRESS = "";
+function maxLeverageThreshold(lpToken, cms) {
+  const lpTokenLC = lpToken.toLowerCase();
+  const ltByCM = cms.map((cm2) => {
+    const lt2 = cm2.liquidationThresholds[lpTokenLC] || 0n;
+    return [cm2.address, lt2];
+  });
+  const sorted = ltByCM.sort(([, ltA], [, ltB]) => {
+    if (ltA > ltB) return -1;
+    if (ltB > ltA) return 1;
+    return 0;
+  });
+  const [cm = EMPTY_ADDRESS, lt = 0n] = sorted[0] || [];
+  return [lt, cm];
+}
+export {
+  maxLeverageThreshold
+};

package/dist/esm/common-utils/utils/strategies/leverage/max-leverage.js

@@ -0,0 +1,11 @@
+import { LEVERAGE_DECIMALS, PERCENTAGE_FACTOR } from "../../../../sdk/index.js";
+import { getFactorFromLeverage } from "./get-factor-from-leverage.js";
+import { maxLeverageThreshold } from "./max-leverage-threshold.js";
+function maxLeverage(lpToken, cms, targetHF = PERCENTAGE_FACTOR) {
+  const [maxThreshold] = maxLeverageThreshold(lpToken, cms);
+  const maxLeverageValue = targetHF * LEVERAGE_DECIMALS / (targetHF - maxThreshold);
+  return getFactorFromLeverage(maxLeverageValue);
+}
+export {
+  maxLeverage
+};

package/dist/esm/common-utils/utils/strategies/sort-strategy-cms-by-availability/index.js

@@ -0,0 +1 @@
+export * from "./sort-strategy-cms-by-availability.js";

package/dist/esm/common-utils/utils/strategies/sort-strategy-cms-by-availability/sort-strategy-cms-by-availability.js

@@ -0,0 +1,43 @@
+import { amountAbcComparator } from "../../creditAccount/sort.js";
+import {
+  cmAvailabilityCondition,
+  getStrategyMaxAPY
+} from "../strategy-info/index.js";
+function sortStrategyCMsByAvailability({
+  targetToken,
+  allCreditManagers,
+  apyListByNetwork,
+  pools,
+  slippage,
+  quotaReserve,
+  leverageLimit,
+  isStrategy
+}) {
+  const list = [...allCreditManagers].sort((cmA, cmB) => {
+    const sort = cmAvailabilityCondition(targetToken, cmA, cmB, pools);
+    if (sort !== 0) return sort;
+    const apyA = getStrategyMaxAPY(
+      targetToken,
+      cmA,
+      apyListByNetwork,
+      slippage,
+      quotaReserve,
+      leverageLimit
+    );
+    const apyB = getStrategyMaxAPY(
+      targetToken,
+      cmB,
+      apyListByNetwork,
+      slippage,
+      quotaReserve,
+      leverageLimit
+    );
+    const sortAPY = isStrategy ? (apyB?.totalMaxApy || 0) - (apyA?.totalMaxApy || 0) : (apyA?.totalBorrowRate || 0) - (apyB?.totalBorrowRate || 0);
+    if (sortAPY !== 0) return sortAPY;
+    return amountAbcComparator(cmA.maxDebt, cmB.maxDebt);
+  });
+  return list;
+}
+export {
+  sortStrategyCMsByAvailability
+};

package/dist/esm/common-utils/utils/strategies/strategy-info/cm-availability-condition.js

@@ -0,0 +1,43 @@
+import {
+  checkBoolean,
+  checkDegenNFT,
+  validateOpenAccountPoolStatus
+} from "../availability/index.js";
+function cmAvailabilityCondition(targetToken, cmA, cmB, pools) {
+  const aHasMinError = validateOpenAccountPoolStatus({
+    pool: pools?.[cmA.pool],
+    debt: cmA.minDebt,
+    creditManager: cmA,
+    targetToken
+  });
+  const bHasMinError = validateOpenAccountPoolStatus({
+    pool: pools?.[cmB.pool],
+    debt: cmB.minDebt,
+    creditManager: cmB,
+    targetToken
+  });
+  const minSort = checkBoolean(!aHasMinError, !bHasMinError);
+  if (minSort !== 0) return minSort;
+  const { freeOfNFT: aFreeOfNFT } = checkDegenNFT(cmA);
+  const { freeOfNFT: bFreeOfNFT } = checkDegenNFT(cmB);
+  const nftSort = checkBoolean(aFreeOfNFT, bFreeOfNFT);
+  if (nftSort !== 0) return nftSort;
+  const aHasMaxError = validateOpenAccountPoolStatus({
+    pool: pools?.[cmA.pool],
+    debt: cmA.maxDebt,
+    creditManager: cmA,
+    targetToken
+  });
+  const bHasMaxError = validateOpenAccountPoolStatus({
+    pool: pools?.[cmB.pool],
+    debt: cmB.maxDebt,
+    creditManager: cmB,
+    targetToken
+  });
+  const maxSort = checkBoolean(!aHasMaxError, !bHasMaxError);
+  if (maxSort !== 0) return maxSort;
+  return 0;
+}
+export {
+  cmAvailabilityCondition
+};

package/dist/esm/common-utils/utils/strategies/strategy-info/get-strategy-info.js

@@ -0,0 +1,74 @@
+import { PriceUtils } from "../../price-math.js";
+import { getFactorFromLeverage } from "../leverage/index.js";
+import { sortStrategyCMsByAvailability } from "../sort-strategy-cms-by-availability/index.js";
+import { getStrategyMaxAPY } from "./get-strategy-max-apy.js";
+import { isStrategyCMDisabled } from "./is-strategy-cm-disabled.js";
+const EMPTY_ADDRESS = "";
+const EMPTY_CHAIN_ID = 0;
+function getStrategyInfo({
+  strategy,
+  creditManagers,
+  sdkStateByChain,
+  apyListByNetwork,
+  quotaReserve,
+  slippage,
+  allPricesByChain
+}) {
+  const strategyCMs = creditManagers?.[strategy.chainId]?.[strategy.id] || {};
+  const strategyCMsList = Object.values(strategyCMs);
+  if (strategyCMsList.length === 0) return void 0;
+  const openableCMsList = strategyCMsList.filter(
+    (cm) => !isStrategyCMDisabled(cm, cm.quotas[strategy.tokenOutAddress])
+  );
+  const currentSdkState = sdkStateByChain?.[strategy.chainId];
+  const pools = currentSdkState?.pools;
+  const tokensList = currentSdkState?.tokens?.tokenDataList;
+  const targetTokenAddress = strategy.tokenOutAddress;
+  const minCreditManager = sortStrategyCMsByAvailability({
+    targetToken: targetTokenAddress,
+    allCreditManagers: openableCMsList.length > 0 ? openableCMsList : strategyCMsList,
+    apyListByNetwork,
+    slippage,
+    quotaReserve,
+    pools,
+    leverageLimit: strategy.maxLeverage,
+    isStrategy: true
+  })?.[0] || strategyCMsList[0];
+  const { underlyingToken = EMPTY_ADDRESS, availableToBorrow = 0n } = minCreditManager || {};
+  const {
+    bonusAPY,
+    totalMaxApy = 0,
+    maxLeverage = 0n,
+    baseBorrowRate = 0,
+    quotaRateMin = 0n
+  } = getStrategyMaxAPY(
+    targetTokenAddress,
+    minCreditManager,
+    apyListByNetwork,
+    slippage,
+    quotaReserve,
+    strategy.maxLeverage
+  ) || {};
+  const prices = allPricesByChain?.[minCreditManager?.chainId ?? EMPTY_CHAIN_ID]?.prices?.[minCreditManager?.pool || EMPTY_ADDRESS];
+  const underlyingPrice = prices?.[underlyingToken] || 0n;
+  const underlyingDecimals = tokensList?.[underlyingToken]?.decimals || 18;
+  const availableToBorrowMoney = PriceUtils.calcTotalPrice(
+    underlyingPrice,
+    availableToBorrow,
+    underlyingDecimals
+  );
+  const r = BigInt(baseBorrowRate) * getFactorFromLeverage(maxLeverage) / maxLeverage;
+  const qr = quotaRateMin;
+  const totalBorrowRate = Number(r + qr);
+  return {
+    maxLeverage,
+    maxAPY: totalMaxApy,
+    bonusAPY,
+    totalBorrowRate,
+    availableToBorrowMoney,
+    minCreditManager
+  };
+}
+export {
+  getStrategyInfo
+};

package/dist/esm/common-utils/utils/strategies/strategy-info/get-strategy-max-apy.js

@@ -0,0 +1,85 @@
+import {
+  LEVERAGE_DECIMALS,
+  PERCENTAGE_FACTOR,
+  toBigInt
+} from "../../../../sdk/index.js";
+import { BONUS_APY_FROM_POINTS } from "../../apy/bonus-apy-from-points.js";
+import { calculateEffectiveBorrowRate } from "../../apy/calculate-effective-borrow-rate.js";
+import { getComplexAPYList } from "../../apy/get-complex-apy-list.js";
+import { getSingleQuotaBorrowRate } from "../../apy/get-single-quota-borrow-rate.js";
+import { maxAPYFormula } from "../../apy/max-apy-formula.js";
+import {
+  calculateMaxLeverageFactor,
+  getLeverageFromFactor
+} from "../leverage/index.js";
+function getStrategyMaxAPY(targetToken, cm, apyListByNetwork, slippage, quotaReserve, leverageLimit) {
+  if (!cm) return void 0;
+  const apyRecord = getComplexAPYList(
+    apyListByNetwork?.[cm.chainId]?.apyList,
+    apyListByNetwork?.[cm.chainId]?.extraCollateralAPYList,
+    cm.pool
+  );
+  const baseRateWithFee = calculateEffectiveBorrowRate({
+    underlyingTokenAddress: cm.underlyingToken,
+    baseRateWithFee: cm.baseBorrowRate,
+    apyList: apyRecord
+  });
+  const lt = cm.liquidationThresholds[targetToken] || 0n;
+  const feeInterest = cm.feeInterest;
+  const tokenQuota = cm.quotas[targetToken] || {
+    token: targetToken,
+    rate: 0n,
+    quotaIncreaseFee: 0n,
+    totalQuoted: 0n,
+    limit: 0n,
+    isActive: true
+  };
+  const qRate = (tokenQuota?.rate || 0n) * lt / PERCENTAGE_FACTOR;
+  const qRate_reserve = qRate * (PERCENTAGE_FACTOR + toBigInt(quotaReserve)) / PERCENTAGE_FACTOR;
+  const quotaRateWithFee = getSingleQuotaBorrowRate({
+    quotaRates: {
+      [targetToken]: {
+        ...tokenQuota,
+        rate: qRate_reserve
+      }
+    },
+    feeInterest,
+    quotas: {
+      [targetToken]: {
+        token: targetToken,
+        balance: 1n
+      }
+    }
+  });
+  const leverage = getLeverageFromFactor(
+    calculateMaxLeverageFactor({
+      targetToken,
+      creditManagers: [cm],
+      slippage,
+      leverageLimit
+    })
+  );
+  const apy = apyRecord?.[targetToken] || 0;
+  const maxAPY = apyRecord ? maxAPYFormula({
+    apy,
+    leverage,
+    baseRateWithFee,
+    quotaRateWithFee: Number(quotaRateWithFee)
+  }) : void 0;
+  const bonusAPY = BONUS_APY_FROM_POINTS[targetToken];
+  const bonusAPYTotal = BigInt(bonusAPY?.value || 0) * leverage / LEVERAGE_DECIMALS;
+  const totalMaxApy = (maxAPY || 0) + Number(bonusAPYTotal);
+  const totalBorrowRate = baseRateWithFee + Number(quotaRateWithFee);
+  return {
+    totalMaxApy,
+    bonusAPY,
+    maxAPY: maxAPY || 0,
+    maxLeverage: leverage,
+    quotaRateMin: quotaRateWithFee,
+    baseBorrowRate: baseRateWithFee,
+    totalBorrowRate
+  };
+}
+export {
+  getStrategyMaxAPY
+};

package/dist/esm/common-utils/utils/strategies/strategy-info/index.js

@@ -0,0 +1,5 @@
+export * from "./cm-availability-condition.js";
+export * from "./get-strategy-info.js";
+export * from "./get-strategy-max-apy.js";
+export * from "./is-strategy-cm-disabled.js";
+export * from "./types.js";

package/dist/esm/common-utils/utils/strategies/strategy-info/is-strategy-cm-disabled.js

@@ -0,0 +1,9 @@
+function isStrategyCMDisabled(cm, quota) {
+  if (!quota) return true;
+  const realLimit = quota.isActive ? quota.limit : 0n;
+  const quotaLeft = realLimit - quota.totalQuoted;
+  return cm.availableToBorrow < cm.minDebt || quotaLeft < cm.minDebt;
+}
+export {
+  isStrategyCMDisabled
+};