@gearbox-protocol/sdk 14.10.1 → 14.10.2-next.2

package/dist/cjs/common-utils/utils/strategies/strategy-info/calculate-total-points.js

@@ -0,0 +1,74 @@
+"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_total_points_exports = {};
+__export(calculate_total_points_exports, {
+  calculateTotalPoints: () => calculateTotalPoints
+});
+module.exports = __toCommonJS(calculate_total_points_exports);
+var import_math = require("../../../../sdk/constants/math.js");
+var import_bigint_math = require("../../bigint-math.js");
+var import_price_math = require("../../price-math.js");
+var import_get_points_rates = require("../points/get-points-rates.js");
+const THRESHOLD_POINTS = 1e3;
+function calculateTotalPoints({
+  pointsAsset,
+  cmAddress,
+  info,
+  totalValue,
+  assetValue,
+  prices,
+  tokensList,
+  underlyingToken
+}) {
+  if (!pointsAsset || !info) return null;
+  if (totalValue === void 0 || totalValue <= 0n) return null;
+  if (assetValue === void 0 || assetValue <= 0n) return null;
+  const { token: tokenAddress, balance: amount } = pointsAsset;
+  const price = prices[tokenAddress] || 0n;
+  const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
+  const money = import_price_math.PriceUtils.calcTotalPrice(price, amount, tokenDecimals);
+  const underlyingPrice = prices[underlyingToken] ?? import_math.PRICE_DECIMALS;
+  const { decimals: underlyingDecimals = 18 } = tokensList[underlyingToken] || {};
+  const assetAmountInUnderlying = import_price_math.PriceUtils.convertByPrice(money, {
+    price: underlyingPrice || import_math.PRICE_DECIMALS,
+    decimals: underlyingDecimals
+  });
+  const percent = assetAmountInUnderlying * import_math.PERCENTAGE_FACTOR / totalValue;
+  if (percent < THRESHOLD_POINTS) return null;
+  const leverage = assetAmountInUnderlying * import_math.LEVERAGE_DECIMALS / assetValue;
+  const rates = (0, import_get_points_rates.getPointsRates)(info.rewards, leverage);
+  const debt = totalValue - assetValue;
+  const leverageDebt = import_bigint_math.BigIntMath.min(assetAmountInUnderlying, debt > 0 ? debt : 0n) * import_math.LEVERAGE_DECIMALS / assetValue;
+  const debtRewardsAvailable = (info.debtRewards || []).filter(
+    (r) => r.cm === cmAddress || r.cm === "any"
+  );
+  const debtRates = (0, import_get_points_rates.getPointsRates)(debtRewardsAvailable, leverageDebt);
+  return {
+    info,
+    rates,
+    debtRates: {
+      rewards: debtRewardsAvailable,
+      rates: debtRates
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateTotalPoints
+});

package/dist/cjs/common-utils/utils/strategies/strategy-info/calculate-total-points.spec.js

@@ -0,0 +1,131 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_math = require("../../../../sdk/constants/math.js");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_calculate_total_points = require("./calculate-total-points.js");
+(0, import_vitest.describe)("calculateTotalPoints", () => {
+  const pointsInfo = {
+    symbol: "PTS",
+    address: import_test_utils.mockToken1,
+    rewards: [
+      {
+        name: "points",
+        units: "pts",
+        multiplier: import_math.LEVERAGE_DECIMALS,
+        type: "base"
+      }
+    ],
+    debtRewards: [
+      {
+        name: "debt",
+        units: "pts",
+        multiplier: import_math.LEVERAGE_DECIMALS,
+        type: "debt",
+        cm: import_test_utils.mockCMAddress
+      }
+    ]
+  };
+  const baseArgs = {
+    pointsAsset: { token: import_test_utils.mockToken1, balance: 1n },
+    cmAddress: import_test_utils.mockCMAddress,
+    info: pointsInfo,
+    totalValue: 10n * import_math.PRICE_DECIMALS,
+    assetValue: 1n,
+    prices: import_test_utils.mockPrices,
+    tokensList: import_test_utils.mockTokenData,
+    underlyingToken: import_test_utils.mockUnderlyingToken
+  };
+  (0, import_vitest.it)("returns null when no pointsAsset or info", () => {
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        pointsAsset: void 0
+      })
+    ).toBeNull();
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        info: void 0
+      })
+    ).toBeNull();
+  });
+  (0, import_vitest.it)("returns null when no totalValue", () => {
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        totalValue: void 0
+      })
+    ).toBeNull();
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        totalValue: 0n
+      })
+    ).toBeNull();
+  });
+  (0, import_vitest.it)("returns null when no assetValue", () => {
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        assetValue: void 0
+      })
+    ).toBeNull();
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        assetValue: 0n
+      })
+    ).toBeNull();
+  });
+  (0, import_vitest.it)("returns null when below threshold", () => {
+    const result = (0, import_calculate_total_points.calculateTotalPoints)({
+      ...baseArgs,
+      totalValue: 10n * import_math.PRICE_DECIMALS
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns points data when above threshold with matching debt rewards", () => {
+    const assetAmount = import_math.PRICE_DECIMALS;
+    const totalValue = 4n * import_math.PRICE_DECIMALS;
+    const assetValue = import_math.PRICE_DECIMALS;
+    const result = (0, import_calculate_total_points.calculateTotalPoints)({
+      pointsAsset: { token: import_test_utils.mockToken1, balance: assetAmount },
+      cmAddress: import_test_utils.mockCMAddress,
+      info: pointsInfo,
+      totalValue,
+      assetValue,
+      prices: {
+        ...import_test_utils.mockPrices,
+        [import_test_utils.mockToken1]: 2n * import_math.PRICE_DECIMALS
+      },
+      tokensList: import_test_utils.mockTokenData,
+      underlyingToken: import_test_utils.mockUnderlyingToken
+    });
+    (0, import_vitest.expect)(result?.info).toBe(pointsInfo);
+    (0, import_vitest.expect)(result?.rates).toEqual([2n * import_math.LEVERAGE_DECIMALS]);
+    (0, import_vitest.expect)(result?.debtRates.rewards).toHaveLength(1);
+    (0, import_vitest.expect)(result?.debtRates.rates).toEqual([2n * import_math.LEVERAGE_DECIMALS]);
+  });
+  (0, import_vitest.it)("returns points data when above threshold with matching debt rewards when debt is lower than asset amount", () => {
+    const assetAmount = import_math.PRICE_DECIMALS;
+    const totalValue = 4n * import_math.PRICE_DECIMALS;
+    const assetValue = import_math.PRICE_DECIMALS;
+    const result = (0, import_calculate_total_points.calculateTotalPoints)({
+      pointsAsset: { token: import_test_utils.mockToken1, balance: assetAmount },
+      cmAddress: import_test_utils.mockCMAddress,
+      info: pointsInfo,
+      totalValue,
+      assetValue,
+      prices: {
+        ...import_test_utils.mockPrices,
+        [import_test_utils.mockToken1]: 4n * import_math.PRICE_DECIMALS
+      },
+      tokensList: import_test_utils.mockTokenData,
+      underlyingToken: import_test_utils.mockUnderlyingToken
+    });
+    (0, import_vitest.expect)(result?.info).toBe(pointsInfo);
+    (0, import_vitest.expect)(result?.rates).toEqual([4n * import_math.LEVERAGE_DECIMALS]);
+    (0, import_vitest.expect)(result?.debtRates.rewards).toHaveLength(1);
+    (0, import_vitest.expect)(result?.debtRates.rates).toEqual([3n * import_math.LEVERAGE_DECIMALS]);
+  });
+});

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

@@ -21,15 +21,16 @@ __export(cm_availability_condition_exports, {
   cmAvailabilityCondition: () => cmAvailabilityCondition
 });
 module.exports = __toCommonJS(cm_availability_condition_exports);
+var import_validate_open_account_pool_status = require("../../validation/validate-open-account-pool-status.js");
 var import_availability = require("../availability/index.js");
 function cmAvailabilityCondition(targetToken, cmA, cmB, pools) {
-  const aHasMinError = (0, import_availability.validateOpenAccountPoolStatus)({
+  const aHasMinError = (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
     pool: pools?.[cmA.pool],
     debt: cmA.minDebt,
     creditManager: cmA,
     targetToken
   });
-  const bHasMinError = (0, import_availability.validateOpenAccountPoolStatus)({
+  const bHasMinError = (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
     pool: pools?.[cmB.pool],
     debt: cmB.minDebt,
     creditManager: cmB,
@@ -41,13 +42,13 @@ function cmAvailabilityCondition(targetToken, cmA, cmB, pools) {
   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)({
+  const aHasMaxError = (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
     pool: pools?.[cmA.pool],
     debt: cmA.maxDebt,
     creditManager: cmA,
     targetToken
   });
-  const bHasMaxError = (0, import_availability.validateOpenAccountPoolStatus)({
+  const bHasMaxError = (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
     pool: pools?.[cmB.pool],
     debt: cmB.maxDebt,
     creditManager: cmB,

package/dist/cjs/common-utils/utils/strategies/strategy-info/get-cm-you-can-earn.js

@@ -0,0 +1,410 @@
+"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_cm_you_can_earn_exports = {};
+__export(get_cm_you_can_earn_exports, {
+  getCMYouCanEarn: () => getCMYouCanEarn
+});
+module.exports = __toCommonJS(get_cm_you_can_earn_exports);
+var import_math = require("../../../../sdk/constants/math.js");
+var import_formatter = require("../../../../sdk/utils/formatter.js");
+var import_calculate_earnings = require("../../apy/calculate-earnings.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_safe_base_borrow_rate = require("../../apy/get-safe-base-borrow-rate.js");
+var import_assets_math = require("../../assets-math.js");
+var import_bigint_math = require("../../bigint-math.js");
+var import_constants = require("../../constants.js");
+var import_calc_health_factor = require("../../creditAccount/calc-health-factor.js");
+var import_quota_utils = require("../../creditAccount/quota-utils.js");
+var import_price_math = require("../../price-math.js");
+var import_is_zero_balance = require("../../validation/is-zero-balance.js");
+var import_validate_balances = require("../../validation/validate-balances.js");
+var import_validate_credit_manager = require("../../validation/validate-credit-manager.js");
+var import_validate_hf = require("../../validation/validate-hf.js");
+var import_validate_open_account = require("../../validation/validate-open-account.js");
+var import_validate_open_account_pool_status = require("../../validation/validate-open-account-pool-status.js");
+var import_validate_token_to_obtain = require("../../validation/validate-token-to-obtain.js");
+var import_get_cm_allowed_collaterals = require("../credit-managers/get-cm-allowed-collaterals.js");
+var import_get_wallet_balances_allowed_on_cm = require("../credit-managers/get-wallet-balances-allowed-on-cm.js");
+var import_get_collateral_by_debt = require("../leverage/get-collateral-by-debt.js");
+var import_get_leverage_from_factor = require("../leverage/get-leverage-from-factor.js");
+var import_get_recommended_debt = require("../leverage/get-recommended-debt.js");
+var import_get_complex_points_list = require("../points/get-complex-points-list.js");
+var import_get_points_info = require("../points/get-points-info.js");
+var import_get_list_with_amount_in_target = require("../tokens/get-list-with-amount-in-target.js");
+var import_calculate_total_apy = require("./calculate-total-apy.js");
+var import_calculate_total_points = require("./calculate-total-points.js");
+function getCMYouCanEarn({
+  allPrices,
+  creditManager,
+  tokensList,
+  delayedPhantoms,
+  nativeTokenAddress,
+  wrappedNativeTokenAddress,
+  walletBalances,
+  strategy,
+  slippage,
+  quotaReserve,
+  apyList,
+  pools
+}) {
+  const baseInfo = {
+    strategy: strategy.name,
+    strategyChainId: strategy.chainId,
+    strategyNetwork: strategy.network,
+    strategyType: strategy.strategyType,
+    creditManager: creditManager.address,
+    cmName: creditManager.name,
+    underlyingToken: tokensList[creditManager.underlyingToken]?.title || creditManager.underlyingToken,
+    targetToken: tokensList[strategy.tokenOutAddress]?.title || strategy.tokenOutAddress
+  };
+  if (!walletBalances) {
+    return {
+      status: "error",
+      description: "No wallet balances",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const targetTokenAddress = strategy.tokenOutAddress;
+  const targetDecimals = tokensList[targetTokenAddress]?.decimals || 18;
+  const prices = allPrices?.[creditManager?.pool || import_constants.EMPTY_ADDRESS];
+  if (!prices) {
+    return {
+      status: "error",
+      description: "No prices for cm pool",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const collateralRecord = (0, import_get_cm_allowed_collaterals.getCMAllowedCollaterals)({
+    creditManager,
+    tokensList,
+    zeroDebt: false,
+    delayedPhantoms,
+    nativeTokenAddress,
+    wrappedNativeTokenAddress,
+    extraCollaterals: {
+      list: strategy.additionalCollaterals,
+      prices
+    }
+  });
+  const walletBalancesSorted = (0, import_get_wallet_balances_allowed_on_cm.getWalletBalancesAllowedOnCM)({
+    walletBalances,
+    collateralRecord,
+    nativeTokenAddress,
+    wrappedNativeTokenAddress,
+    tokensList,
+    prices,
+    isPaused: creditManager?.isPaused
+  });
+  const filtered = walletBalancesSorted.filter((a) => !(0, import_is_zero_balance.isZeroBalance)(a.balance));
+  const collateral_initial = filtered[0];
+  if (!collateral_initial || collateral_initial.balance === 0n) {
+    return {
+      status: "error",
+      description: `Initial collateral is zero`,
+      otherInfo: {
+        ...baseInfo,
+        walletBalancesSorted,
+        filtered
+      },
+      data: void 0
+    };
+  }
+  const collateralPrice = prices[collateral_initial.token] || 0n;
+  const collateralDecimals = tokensList[collateral_initial.token]?.decimals || 18;
+  const underlyingPrice = prices[creditManager.underlyingToken] || 0n;
+  const underlyingDecimals = tokensList[creditManager.underlyingToken]?.decimals || 18;
+  const assetValueFrom_initial = import_price_math.PriceUtils.convertByPrice(
+    import_price_math.PriceUtils.calcTotalPrice(
+      collateralPrice,
+      collateral_initial.balance,
+      collateralDecimals
+    ),
+    {
+      price: underlyingPrice,
+      decimals: underlyingDecimals
+    }
+  );
+  if (!assetValueFrom_initial || assetValueFrom_initial === 0n) {
+    return {
+      status: "error",
+      description: "Initial asset value from is zero",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const recommendedDebt_initial = (0, import_get_recommended_debt.getRecommendedDebt)({
+    targetToken: targetTokenAddress,
+    amount: assetValueFrom_initial,
+    creditManager,
+    slippage,
+    swapCollateral: true,
+    leverageLimit: strategy.maxLeverage
+  });
+  const lt = creditManager.liquidationThresholds[targetTokenAddress] || 0n;
+  const recommendedAssetValueFrom = (0, import_get_collateral_by_debt.getCollateralByDebt)(
+    recommendedDebt_initial.maxDebt,
+    lt,
+    (0, import_formatter.toBN)("1.013", 4)
+  );
+  const assetValueFrom = import_bigint_math.BigIntMath.min(
+    assetValueFrom_initial,
+    recommendedAssetValueFrom
+  );
+  if (!assetValueFrom || assetValueFrom === 0n) {
+    return {
+      status: "error",
+      description: "Asset value from is zero",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const assetValueFromTarget = import_price_math.PriceUtils.convertByPrice(
+    import_price_math.PriceUtils.calcTotalPrice(
+      underlyingPrice,
+      assetValueFrom,
+      underlyingDecimals
+    ),
+    {
+      price: collateralPrice,
+      decimals: collateralDecimals
+    }
+  );
+  const collateral = [
+    { token: collateral_initial.token, balance: assetValueFromTarget }
+  ];
+  const recommendedDebt = (0, import_get_recommended_debt.getRecommendedDebt)({
+    targetToken: targetTokenAddress,
+    amount: assetValueFrom,
+    creditManager,
+    slippage,
+    swapCollateral: true,
+    leverageLimit: strategy.maxLeverage
+  });
+  const debt = recommendedDebt.maxDebt;
+  const totalAmount = assetValueFrom + debt;
+  const targetPrice = prices[targetTokenAddress] || 0n;
+  const totalAmountInTarget = import_price_math.PriceUtils.convertByPrice(
+    import_price_math.PriceUtils.calcTotalPrice(underlyingPrice, totalAmount, underlyingDecimals),
+    {
+      price: targetPrice,
+      decimals: targetDecimals
+    }
+  );
+  const assets = [
+    {
+      token: targetTokenAddress,
+      balance: totalAmountInTarget
+    }
+  ];
+  const assetsWithAmountInTarget = (0, import_get_list_with_amount_in_target.getListWithAmountInTarget)({
+    assets,
+    targetToken: creditManager.underlyingToken,
+    prices,
+    tokensList
+  });
+  const assetsWithAmountInTargetRecord = import_assets_math.AssetUtils.constructAssetRecord(
+    assetsWithAmountInTarget
+  );
+  const quotasAfter = (0, import_quota_utils.calcQuotaUpdate)({
+    quotas: creditManager.quotas,
+    initialQuotas: import_constants.EMPTY_OBJECT,
+    assetsAfterUpdate: assetsWithAmountInTargetRecord,
+    allowedToObtain: assetsWithAmountInTargetRecord,
+    allowedToSpend: import_constants.EMPTY_OBJECT,
+    quotaReserve: (0, import_formatter.toBigInt)(quotaReserve),
+    maxDebt: creditManager.maxDebt,
+    calcModification: void 0,
+    liquidationThresholds: creditManager.liquidationThresholds
+  });
+  const desiredQuota = quotasAfter.desiredQuota;
+  const quotaDecrease = quotasAfter.quotaDecrease;
+  const quotaIncrease = quotasAfter.quotaIncrease;
+  const quotaUpdate = [...quotaDecrease, ...quotaIncrease];
+  const hf = (0, import_calc_health_factor.calcHealthFactor)({
+    assets: assetsWithAmountInTarget,
+    quotas: desiredQuota,
+    prices,
+    liquidationThresholds: creditManager.liquidationThresholds,
+    underlyingToken: creditManager.underlyingToken,
+    debt,
+    quotasInfo: creditManager.quotas,
+    tokensList
+  });
+  const pool = pools?.[creditManager.pool];
+  const error = (0, import_validate_credit_manager.validateCreditManager)({ creditManager }) || (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
+    pool,
+    creditManager,
+    debt,
+    targetToken: targetTokenAddress
+  }) || (0, import_validate_token_to_obtain.validateTokenToObtain)({
+    targetToken: strategy.tokenOutAddress,
+    creditManager
+  }) || (0, import_validate_balances.validateBalances)({
+    balances: walletBalances,
+    assets: collateral
+  }) || (0, import_validate_open_account.validateOpenAccount)({
+    desiredQuota,
+    quotaUpdate,
+    debt,
+    creditManager,
+    loading: false
+  }) || (0, import_validate_hf.validateHF)({ hf });
+  if (error) {
+    return {
+      status: "error",
+      description: `Resulting CA did not pass validation: ${error.message}`,
+      otherInfo: {
+        ...baseInfo,
+        hf
+      },
+      data: void 0
+    };
+  }
+  const apyRecord = (0, import_get_complex_apy_list.getComplexAPYList)(
+    apyList?.apyList,
+    apyList?.extraCollateralAPYList,
+    creditManager.pool
+  );
+  if (!apyRecord) {
+    return {
+      status: "error",
+      description: "No complex apy record",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const pointsList = (0, import_get_complex_points_list.getComplexPointsList)(
+    apyList?.pointsList,
+    apyList?.extraCollateralPointsList,
+    pool?.address
+  );
+  if (!pointsList) {
+    return {
+      status: "error",
+      description: "No complex points record",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const pointsInfo = (0, import_get_points_info.getPointsInfo)({
+    chainId: strategy.chainId,
+    pointsList,
+    token: strategy.tokenOutAddress,
+    creditManagers: {
+      [creditManager.address]: creditManager
+    }
+  });
+  const baseBorrowRateTo = pool ? (0, import_get_safe_base_borrow_rate.getSafeBaseBorrowRate)({
+    creditManager,
+    pool,
+    availableLiquidityChange: debt * -1n
+  }) : creditManager.baseBorrowRate;
+  const effectiveBorrowRate = (0, import_calculate_effective_borrow_rate.calculateEffectiveBorrowRate)({
+    underlyingTokenAddress: creditManager.underlyingToken,
+    baseRateWithFee: baseBorrowRateTo,
+    apyList: apyRecord
+  });
+  const totalAPY = (0, import_calculate_total_apy.calculateTotalAPY)({
+    caAssets: assetsWithAmountInTarget,
+    lpAPY: apyRecord,
+    prices,
+    quotaRates: creditManager.quotas,
+    quotas: desiredQuota,
+    feeInterest: creditManager.feeInterest,
+    totalValue: totalAmount,
+    debt,
+    underlyingToken: creditManager.underlyingToken,
+    tokensList,
+    pointsInfo,
+    effectiveBorrowRate,
+    showAPY: true
+  });
+  const earn = (0, import_calculate_earnings.calculateEarnings)({
+    overallAPYBigInt: totalAPY.overallAPYBigInt,
+    targetAmount: assetValueFrom,
+    targetToken: creditManager.underlyingToken,
+    tokensList,
+    prices
+  });
+  const points = (0, import_calculate_total_points.calculateTotalPoints)({
+    pointsAsset: pointsInfo ? assetsWithAmountInTarget[0] : void 0,
+    cmAddress: creditManager.address,
+    info: pointsInfo,
+    totalValue: totalAmount,
+    assetValue: assetValueFrom,
+    prices,
+    tokensList,
+    underlyingToken: creditManager.underlyingToken
+  });
+  const leverage = (0, import_get_leverage_from_factor.getLeverageFromFactor)(
+    debt * import_math.LEVERAGE_DECIMALS / assetValueFrom
+  );
+  const info = {
+    info: {
+      strategy,
+      creditManager,
+      collateral,
+      assetsWithAmountInTarget,
+      assetValue: assetValueFrom,
+      debt,
+      totalAmount,
+      assetValueInUSD: import_price_math.PriceUtils.calcTotalPrice(
+        underlyingPrice,
+        assetValueFrom,
+        underlyingDecimals
+      ),
+      maxAPY: totalAPY,
+      bonusAPY: void 0,
+      extraAPY: [],
+      maxLeverage: leverage
+    },
+    earnings: earn,
+    points,
+    otherInfo: {
+      ...baseInfo,
+      collateral: collateral.map((c) => ({
+        token: tokensList[c.token]?.title || c.token,
+        balance: (0, import_formatter.formatBN)(c.balance, import_math.WAD_DECIMALS_POW, 4)
+      })),
+      apy: (0, import_formatter.formatBN)(totalAPY.overallAPYBigInt || 0, 4, 4),
+      earningsUSD: (0, import_formatter.formatBN)(earn.earningsUSD || 0n, import_math.WAD_DECIMALS_POW, 4),
+      assetValue: (0, import_formatter.formatBN)(assetValueFrom, targetDecimals, 4),
+      debt: (0, import_formatter.formatBN)(debt, targetDecimals, 4),
+      totalAmount: (0, import_formatter.formatBN)(totalAmount, underlyingDecimals, 4),
+      assetValueFrom_initial: (0, import_formatter.formatBN)(
+        assetValueFrom_initial,
+        targetDecimals,
+        4
+      ),
+      debt_initial: (0, import_formatter.formatBN)(
+        recommendedDebt_initial.maxDebt,
+        targetDecimals,
+        4
+      )
+    }
+  };
+  return { status: "ok", description: "ok", data: info };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCMYouCanEarn
+});