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

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

@@ -0,0 +1,45 @@
+"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 calculate_max_leverage_factor_exports = {};
+__export(calculate_max_leverage_factor_exports, {
+  calculateMaxLeverageFactor: () => calculateMaxLeverageFactor
+});
+module.exports = __toCommonJS(calculate_max_leverage_factor_exports);
+var import_sdk = require("../../../../sdk/index.js");
+var import_bigint_math = require("../../bigint-math.js");
+var import_calculate_loss_coefficient = require("./calculate-loss-coefficient.js");
+var import_max_leverage = require("./max-leverage.js");
+const DEFAULT_LEVERAGE_CONSTANT_LOSS = 500n;
+function calculateMaxLeverageFactor({
+  targetToken,
+  slippage,
+  creditManagers,
+  constantLoss = DEFAULT_LEVERAGE_CONSTANT_LOSS,
+  leverageLimit
+}) {
+  const maxPossibleLeverage = (0, import_max_leverage.maxLeverage)(targetToken, creditManagers);
+  const coefficient = (0, import_calculate_loss_coefficient.calculateLossCoefficient)(slippage, constantLoss);
+  const maxLeverageValue = BigInt(maxPossibleLeverage) * coefficient / import_sdk.PERCENTAGE_FACTOR;
+  const r = leverageLimit !== void 0 ? import_bigint_math.BigIntMath.min(BigInt(leverageLimit), maxLeverageValue) : maxLeverageValue;
+  return r;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateMaxLeverageFactor
+});

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

@@ -0,0 +1,31 @@
+"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 get_factor_from_leverage_exports = {};
+__export(get_factor_from_leverage_exports, {
+  getFactorFromLeverage: () => getFactorFromLeverage
+});
+module.exports = __toCommonJS(get_factor_from_leverage_exports);
+var import_sdk = require("../../../../sdk/index.js");
+function getFactorFromLeverage(leverage) {
+  return leverage - import_sdk.LEVERAGE_DECIMALS;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFactorFromLeverage
+});

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

@@ -0,0 +1,31 @@
+"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 get_leverage_from_factor_exports = {};
+__export(get_leverage_from_factor_exports, {
+  getLeverageFromFactor: () => getLeverageFromFactor
+});
+module.exports = __toCommonJS(get_leverage_from_factor_exports);
+var import_sdk = require("../../../../sdk/index.js");
+function getLeverageFromFactor(factor) {
+  return factor + import_sdk.LEVERAGE_DECIMALS;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLeverageFromFactor
+});

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

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var leverage_exports = {};
+module.exports = __toCommonJS(leverage_exports);
+__reExport(leverage_exports, require("./calculate-loss-coefficient.js"), module.exports);
+__reExport(leverage_exports, require("./calculate-max-leverage-factor.js"), module.exports);
+__reExport(leverage_exports, require("./get-factor-from-leverage.js"), module.exports);
+__reExport(leverage_exports, require("./get-leverage-from-factor.js"), module.exports);
+__reExport(leverage_exports, require("./max-leverage.js"), module.exports);
+__reExport(leverage_exports, require("./max-leverage-threshold.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./calculate-loss-coefficient.js"),
+  ...require("./calculate-max-leverage-factor.js"),
+  ...require("./get-factor-from-leverage.js"),
+  ...require("./get-leverage-from-factor.js"),
+  ...require("./max-leverage.js"),
+  ...require("./max-leverage-threshold.js")
+});

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

@@ -0,0 +1,42 @@
+"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 max_leverage_threshold_exports = {};
+__export(max_leverage_threshold_exports, {
+  maxLeverageThreshold: () => maxLeverageThreshold
+});
+module.exports = __toCommonJS(max_leverage_threshold_exports);
+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];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  maxLeverageThreshold
+});

package/dist/cjs/common-utils/utils/strategies/leverage/max-leverage.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 max_leverage_exports = {};
+__export(max_leverage_exports, {
+  maxLeverage: () => maxLeverage
+});
+module.exports = __toCommonJS(max_leverage_exports);
+var import_sdk = require("../../../../sdk/index.js");
+var import_get_factor_from_leverage = require("./get-factor-from-leverage.js");
+var import_max_leverage_threshold = require("./max-leverage-threshold.js");
+function maxLeverage(lpToken, cms, targetHF = import_sdk.PERCENTAGE_FACTOR) {
+  const [maxThreshold] = (0, import_max_leverage_threshold.maxLeverageThreshold)(lpToken, cms);
+  const maxLeverageValue = targetHF * import_sdk.LEVERAGE_DECIMALS / (targetHF - maxThreshold);
+  return (0, import_get_factor_from_leverage.getFactorFromLeverage)(maxLeverageValue);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  maxLeverage
+});

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

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sort_strategy_cms_by_availability_exports = {};
+module.exports = __toCommonJS(sort_strategy_cms_by_availability_exports);
+__reExport(sort_strategy_cms_by_availability_exports, require("./sort-strategy-cms-by-availability.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./sort-strategy-cms-by-availability.js")
+});

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

@@ -0,0 +1,64 @@
+"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 sort_strategy_cms_by_availability_exports = {};
+__export(sort_strategy_cms_by_availability_exports, {
+  sortStrategyCMsByAvailability: () => sortStrategyCMsByAvailability
+});
+module.exports = __toCommonJS(sort_strategy_cms_by_availability_exports);
+var import_sort = require("../../creditAccount/sort.js");
+var import_strategy_info = require("../strategy-info/index.js");
+function sortStrategyCMsByAvailability({
+  targetToken,
+  allCreditManagers,
+  apyListByNetwork,
+  pools,
+  slippage,
+  quotaReserve,
+  leverageLimit,
+  isStrategy
+}) {
+  const list = [...allCreditManagers].sort((cmA, cmB) => {
+    const sort = (0, import_strategy_info.cmAvailabilityCondition)(targetToken, cmA, cmB, pools);
+    if (sort !== 0) return sort;
+    const apyA = (0, import_strategy_info.getStrategyMaxAPY)(
+      targetToken,
+      cmA,
+      apyListByNetwork,
+      slippage,
+      quotaReserve,
+      leverageLimit
+    );
+    const apyB = (0, import_strategy_info.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 (0, import_sort.amountAbcComparator)(cmA.maxDebt, cmB.maxDebt);
+  });
+  return list;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sortStrategyCMsByAvailability
+});

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

@@ -0,0 +1,63 @@
+"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 cm_availability_condition_exports = {};
+__export(cm_availability_condition_exports, {
+  cmAvailabilityCondition: () => cmAvailabilityCondition
+});
+module.exports = __toCommonJS(cm_availability_condition_exports);
+var import_availability = require("../availability/index.js");
+function cmAvailabilityCondition(targetToken, cmA, cmB, pools) {
+  const aHasMinError = (0, import_availability.validateOpenAccountPoolStatus)({
+    pool: pools?.[cmA.pool],
+    debt: cmA.minDebt,
+    creditManager: cmA,
+    targetToken
+  });
+  const bHasMinError = (0, import_availability.validateOpenAccountPoolStatus)({
+    pool: pools?.[cmB.pool],
+    debt: cmB.minDebt,
+    creditManager: cmB,
+    targetToken
+  });
+  const minSort = (0, import_availability.checkBoolean)(!aHasMinError, !bHasMinError);
+  if (minSort !== 0) return minSort;
+  const { freeOfNFT: aFreeOfNFT } = (0, import_availability.checkDegenNFT)(cmA);
+  const { freeOfNFT: bFreeOfNFT } = (0, import_availability.checkDegenNFT)(cmB);
+  const nftSort = (0, import_availability.checkBoolean)(aFreeOfNFT, bFreeOfNFT);
+  if (nftSort !== 0) return nftSort;
+  const aHasMaxError = (0, import_availability.validateOpenAccountPoolStatus)({
+    pool: pools?.[cmA.pool],
+    debt: cmA.maxDebt,
+    creditManager: cmA,
+    targetToken
+  });
+  const bHasMaxError = (0, import_availability.validateOpenAccountPoolStatus)({
+    pool: pools?.[cmB.pool],
+    debt: cmB.maxDebt,
+    creditManager: cmB,
+    targetToken
+  });
+  const maxSort = (0, import_availability.checkBoolean)(!aHasMaxError, !bHasMaxError);
+  if (maxSort !== 0) return maxSort;
+  return 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cmAvailabilityCondition
+});

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

@@ -0,0 +1,98 @@
+"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 get_strategy_info_exports = {};
+__export(get_strategy_info_exports, {
+  getStrategyInfo: () => getStrategyInfo
+});
+module.exports = __toCommonJS(get_strategy_info_exports);
+var import_price_math = require("../../price-math.js");
+var import_leverage = require("../leverage/index.js");
+var import_sort_strategy_cms_by_availability = require("../sort-strategy-cms-by-availability/index.js");
+var import_get_strategy_max_apy = require("./get-strategy-max-apy.js");
+var import_is_strategy_cm_disabled = require("./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) => !(0, import_is_strategy_cm_disabled.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 = (0, import_sort_strategy_cms_by_availability.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
+  } = (0, import_get_strategy_max_apy.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 = import_price_math.PriceUtils.calcTotalPrice(
+    underlyingPrice,
+    availableToBorrow,
+    underlyingDecimals
+  );
+  const r = BigInt(baseBorrowRate) * (0, import_leverage.getFactorFromLeverage)(maxLeverage) / maxLeverage;
+  const qr = quotaRateMin;
+  const totalBorrowRate = Number(r + qr);
+  return {
+    maxLeverage,
+    maxAPY: totalMaxApy,
+    bonusAPY,
+    totalBorrowRate,
+    availableToBorrowMoney,
+    minCreditManager
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStrategyInfo
+});

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

@@ -0,0 +1,102 @@
+"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 get_strategy_max_apy_exports = {};
+__export(get_strategy_max_apy_exports, {
+  getStrategyMaxAPY: () => getStrategyMaxAPY
+});
+module.exports = __toCommonJS(get_strategy_max_apy_exports);
+var import_sdk = require("../../../../sdk/index.js");
+var import_bonus_apy_from_points = require("../../apy/bonus-apy-from-points.js");
+var import_calculate_effective_borrow_rate = require("../../apy/calculate-effective-borrow-rate.js");
+var import_get_complex_apy_list = require("../../apy/get-complex-apy-list.js");
+var import_get_single_quota_borrow_rate = require("../../apy/get-single-quota-borrow-rate.js");
+var import_max_apy_formula = require("../../apy/max-apy-formula.js");
+var import_leverage = require("../leverage/index.js");
+function getStrategyMaxAPY(targetToken, cm, apyListByNetwork, slippage, quotaReserve, leverageLimit) {
+  if (!cm) return void 0;
+  const apyRecord = (0, import_get_complex_apy_list.getComplexAPYList)(
+    apyListByNetwork?.[cm.chainId]?.apyList,
+    apyListByNetwork?.[cm.chainId]?.extraCollateralAPYList,
+    cm.pool
+  );
+  const baseRateWithFee = (0, import_calculate_effective_borrow_rate.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 / import_sdk.PERCENTAGE_FACTOR;
+  const qRate_reserve = qRate * (import_sdk.PERCENTAGE_FACTOR + (0, import_sdk.toBigInt)(quotaReserve)) / import_sdk.PERCENTAGE_FACTOR;
+  const quotaRateWithFee = (0, import_get_single_quota_borrow_rate.getSingleQuotaBorrowRate)({
+    quotaRates: {
+      [targetToken]: {
+        ...tokenQuota,
+        rate: qRate_reserve
+      }
+    },
+    feeInterest,
+    quotas: {
+      [targetToken]: {
+        token: targetToken,
+        balance: 1n
+      }
+    }
+  });
+  const leverage = (0, import_leverage.getLeverageFromFactor)(
+    (0, import_leverage.calculateMaxLeverageFactor)({
+      targetToken,
+      creditManagers: [cm],
+      slippage,
+      leverageLimit
+    })
+  );
+  const apy = apyRecord?.[targetToken] || 0;
+  const maxAPY = apyRecord ? (0, import_max_apy_formula.maxAPYFormula)({
+    apy,
+    leverage,
+    baseRateWithFee,
+    quotaRateWithFee: Number(quotaRateWithFee)
+  }) : void 0;
+  const bonusAPY = import_bonus_apy_from_points.BONUS_APY_FROM_POINTS[targetToken];
+  const bonusAPYTotal = BigInt(bonusAPY?.value || 0) * leverage / import_sdk.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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStrategyMaxAPY
+});

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

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var strategy_info_exports = {};
+module.exports = __toCommonJS(strategy_info_exports);
+__reExport(strategy_info_exports, require("./cm-availability-condition.js"), module.exports);
+__reExport(strategy_info_exports, require("./get-strategy-info.js"), module.exports);
+__reExport(strategy_info_exports, require("./get-strategy-max-apy.js"), module.exports);
+__reExport(strategy_info_exports, require("./is-strategy-cm-disabled.js"), module.exports);
+__reExport(strategy_info_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./cm-availability-condition.js"),
+  ...require("./get-strategy-info.js"),
+  ...require("./get-strategy-max-apy.js"),
+  ...require("./is-strategy-cm-disabled.js"),
+  ...require("./types.js")
+});

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

@@ -0,0 +1,33 @@
+"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 is_strategy_cm_disabled_exports = {};
+__export(is_strategy_cm_disabled_exports, {
+  isStrategyCMDisabled: () => isStrategyCMDisabled
+});
+module.exports = __toCommonJS(is_strategy_cm_disabled_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isStrategyCMDisabled
+});

package/dist/cjs/common-utils/utils/strategies/strategy-info/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);