@gearbox-protocol/sdk 16.0.0-next.5 → 16.0.0-next.50

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

@@ -1,42 +0,0 @@
-import { checkBoolean } from "../availability/check-boolean.js";
-import { checkDegenNFT } from "../availability/check-degen-nft.js";
-import "../availability/index.js";
-import { validateOpenAccountPoolStatus } from "../../validation/validate-open-account-pool-status.js";
-//#region src/common-utils/utils/strategies/strategy-info/cm-availability-condition.ts
-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;
-}
-//#endregion
-export { cmAvailabilityCondition };

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

@@ -1,307 +0,0 @@
-import { BigIntMath } from "../../../../onchain/utils/bigint-math.js";
-import { LEVERAGE_DECIMALS } from "../../../../onchain/constants/math.js";
-import { formatBN, toBN, toBigInt } from "../../../../onchain/utils/formatter.js";
-import { validateHF } from "../../validation/validate-hf.js";
-import { calcQuotaUpdate } from "../../creditAccount/quota-utils.js";
-import { PriceUtils } from "../../price-math.js";
-import { calculateEarnings } from "../../apy/calculate-earnings.js";
-import { calculateEffectiveBorrowRate } from "../../apy/calculate-effective-borrow-rate.js";
-import { getComplexAPYList } from "../../apy/get-complex-apy-list.js";
-import { getSafeBaseBorrowRate } from "../../apy/get-safe-base-borrow-rate.js";
-import { getCollateralByDebt } from "../leverage/get-collateral-by-debt.js";
-import { getLeverageFromFactor } from "../leverage/get-leverage-from-factor.js";
-import { getRecommendedDebt } from "../leverage/get-recommended-debt.js";
-import { AssetUtils } from "../../assets-math.js";
-import { EMPTY_OBJECT } from "../../constants.js";
-import { calcHealthFactor } from "../../creditAccount/calc-health-factor.js";
-import { getCMAllowedCollaterals } from "../credit-managers/get-cm-allowed-collaterals.js";
-import { getListWithAmountInTarget } from "../tokens/get-list-with-amount-in-target.js";
-import { getWalletBalancesAllowedOnCM } from "../credit-managers/get-wallet-balances-allowed-on-cm.js";
-import { getComplexPointsList } from "../points/get-complex-points-list.js";
-import { getPointsInfo } from "../points/get-points-info.js";
-import { validateOpenAccountPoolStatus } from "../../validation/validate-open-account-pool-status.js";
-import { calculateTotalAPY } from "./calculate-total-apy.js";
-import { calculateTotalPoints } from "./calculate-total-points.js";
-import { isZeroBalance } from "../../validation/is-zero-balance.js";
-import { validateBalances } from "../../validation/validate-balances.js";
-import { validateCreditManager } from "../../validation/validate-credit-manager.js";
-import { validateOpenAccount } from "../../validation/validate-open-account.js";
-import { validateTokenToObtain } from "../../validation/validate-token-to-obtain.js";
-//#region src/common-utils/utils/strategies/strategy-info/get-cm-you-can-earn.ts
-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 || ""];
-	if (!prices) return {
-		status: "error",
-		description: "No prices for cm pool",
-		otherInfo: baseInfo,
-		data: void 0
-	};
-	const collateralRecord = getCMAllowedCollaterals({
-		creditManager,
-		tokensList,
-		zeroDebt: false,
-		delayedPhantoms,
-		nativeTokenAddress,
-		wrappedNativeTokenAddress,
-		extraCollaterals: {
-			list: strategy.additionalCollaterals,
-			prices
-		}
-	});
-	const walletBalancesSorted = getWalletBalancesAllowedOnCM({
-		walletBalances,
-		collateralRecord,
-		nativeTokenAddress,
-		wrappedNativeTokenAddress,
-		tokensList,
-		prices,
-		isPaused: creditManager?.isPaused
-	});
-	const filtered = walletBalancesSorted.filter((a) => !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 = PriceUtils.convertByPrice(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 = getRecommendedDebt({
-		targetToken: targetTokenAddress,
-		amount: assetValueFrom_initial,
-		creditManager,
-		slippage,
-		swapCollateral: true,
-		leverageLimit: strategy.maxLeverage
-	});
-	const lt = creditManager.liquidationThresholds[targetTokenAddress] || 0n;
-	const recommendedAssetValueFrom = getCollateralByDebt(recommendedDebt_initial.maxDebt, lt, toBN("1.013", 4));
-	const assetValueFrom = 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 = PriceUtils.convertByPrice(PriceUtils.calcTotalPrice(underlyingPrice, assetValueFrom, underlyingDecimals), {
-		price: collateralPrice,
-		decimals: collateralDecimals
-	});
-	const collateral = [{
-		token: collateral_initial.token,
-		balance: assetValueFromTarget
-	}];
-	const debt = getRecommendedDebt({
-		targetToken: targetTokenAddress,
-		amount: assetValueFrom,
-		creditManager,
-		slippage,
-		swapCollateral: true,
-		leverageLimit: strategy.maxLeverage
-	}).maxDebt;
-	const totalAmount = assetValueFrom + debt;
-	const targetPrice = prices[targetTokenAddress] || 0n;
-	const assets = [{
-		token: targetTokenAddress,
-		balance: PriceUtils.convertByPrice(PriceUtils.calcTotalPrice(underlyingPrice, totalAmount, underlyingDecimals), {
-			price: targetPrice,
-			decimals: targetDecimals
-		})
-	}];
-	const assetsWithAmountInTarget = getListWithAmountInTarget({
-		assets,
-		targetToken: creditManager.underlyingToken,
-		prices,
-		tokensList
-	});
-	const assetsWithAmountInTargetRecord = AssetUtils.constructAssetRecord(assetsWithAmountInTarget);
-	const quotasAfter = calcQuotaUpdate({
-		quotas: creditManager.quotas,
-		initialQuotas: EMPTY_OBJECT,
-		assetsAfterUpdate: assetsWithAmountInTargetRecord,
-		allowedToObtain: assetsWithAmountInTargetRecord,
-		allowedToSpend: EMPTY_OBJECT,
-		quotaReserve: 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 = calcHealthFactor({
-		assets: assetsWithAmountInTarget,
-		quotas: desiredQuota,
-		prices,
-		liquidationThresholds: creditManager.liquidationThresholds,
-		underlyingToken: creditManager.underlyingToken,
-		debt,
-		quotasInfo: creditManager.quotas,
-		tokensList
-	});
-	const pool = pools?.[creditManager.pool];
-	const error = validateCreditManager({ creditManager }) || validateOpenAccountPoolStatus({
-		pool,
-		creditManager,
-		debt,
-		targetToken: targetTokenAddress
-	}) || validateTokenToObtain({
-		targetToken: strategy.tokenOutAddress,
-		creditManager
-	}) || validateBalances({
-		balances: walletBalances,
-		assets: collateral
-	}) || validateOpenAccount({
-		desiredQuota,
-		quotaUpdate,
-		debt,
-		creditManager,
-		loading: false
-	}) || validateHF({ hf });
-	if (error) return {
-		status: "error",
-		description: `Resulting CA did not pass validation: ${error.message}`,
-		otherInfo: {
-			...baseInfo,
-			hf
-		},
-		data: void 0
-	};
-	const apyRecord = getComplexAPYList(apyList?.apyList, apyList?.extraCollateralAPYList, creditManager.pool);
-	if (!apyRecord) return {
-		status: "error",
-		description: "No complex apy record",
-		otherInfo: baseInfo,
-		data: void 0
-	};
-	const pointsList = getComplexPointsList(apyList?.pointsList, apyList?.extraCollateralPointsList, pool?.address);
-	if (!pointsList) return {
-		status: "error",
-		description: "No complex points record",
-		otherInfo: baseInfo,
-		data: void 0
-	};
-	const pointsInfo = getPointsInfo({
-		chainId: strategy.chainId,
-		pointsList,
-		token: strategy.tokenOutAddress,
-		creditManagers: { [creditManager.address]: creditManager }
-	});
-	const baseBorrowRateTo = pool ? getSafeBaseBorrowRate({
-		creditManager,
-		pool,
-		availableLiquidityChange: debt * -1n
-	}) : creditManager.baseBorrowRate;
-	const effectiveBorrowRate = calculateEffectiveBorrowRate({
-		underlyingTokenAddress: creditManager.underlyingToken,
-		baseRateWithFee: baseBorrowRateTo,
-		apyList: apyRecord
-	});
-	const totalAPY = 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 = calculateEarnings({
-		overallAPYBigInt: totalAPY.overallAPYBigInt,
-		targetAmount: assetValueFrom,
-		targetToken: creditManager.underlyingToken,
-		tokensList,
-		prices
-	});
-	const points = calculateTotalPoints({
-		pointsAsset: pointsInfo ? assetsWithAmountInTarget[0] : void 0,
-		cmAddress: creditManager.address,
-		info: pointsInfo,
-		totalValue: totalAmount,
-		assetValue: assetValueFrom,
-		prices,
-		tokensList,
-		underlyingToken: creditManager.underlyingToken
-	});
-	const leverage = getLeverageFromFactor(debt * LEVERAGE_DECIMALS / assetValueFrom);
-	return {
-		status: "ok",
-		description: "ok",
-		data: {
-			info: {
-				strategy,
-				creditManager,
-				collateral,
-				assetsWithAmountInTarget,
-				assetValue: assetValueFrom,
-				debt,
-				totalAmount,
-				assetValueInUSD: 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: formatBN(c.balance, 18, 4)
-				})),
-				apy: formatBN(totalAPY.overallAPYBigInt || 0, 4, 4),
-				earningsUSD: formatBN(earn.earningsUSD || 0n, 18, 4),
-				assetValue: formatBN(assetValueFrom, targetDecimals, 4),
-				debt: formatBN(debt, targetDecimals, 4),
-				totalAmount: formatBN(totalAmount, underlyingDecimals, 4),
-				assetValueFrom_initial: formatBN(assetValueFrom_initial, targetDecimals, 4),
-				debt_initial: formatBN(recommendedDebt_initial.maxDebt, targetDecimals, 4)
-			}
-		}
-	};
-}
-//#endregion
-export { getCMYouCanEarn };

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

@@ -1,264 +0,0 @@
-import { toBN } from "../../../../onchain/utils/formatter.js";
-import { getCMYouCanEarn } from "./get-cm-you-can-earn.js";
-import { buildCreditManager, buildPool, buildQuota, buildTokenData } from "../../../test-utils/index.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/strategies/strategy-info/get-cm-you-can-earn.spec.ts
-describe("getCMYouCanEarn", () => {
-	const collateralTokenAddress = "0xcd5fe23c85820f7b72d0926fc9b05b43e359b7ee";
-	const targetTokenAddress = "0xe72b141df173b999ae7c1adcbf60cc9833ce56a8";
-	const underlyingTokenAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
-	const deth = "0x871ab8e36cae9af35c6a3488b049965233deb7ed";
-	const nativeTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
-	const wrappedNativeTokenAddress = underlyingTokenAddress;
-	const tokenDataList = {
-		[collateralTokenAddress]: buildTokenData(collateralTokenAddress, "weETH"),
-		[targetTokenAddress]: buildTokenData(targetTokenAddress, "ethPlus"),
-		[underlyingTokenAddress]: buildTokenData(underlyingTokenAddress, "WETH"),
-		[nativeTokenAddress]: buildTokenData(nativeTokenAddress, "ETH"),
-		[deth]: buildTokenData(deth, "dETH")
-	};
-	const poolAddress = "0x0000000000000000000000000000000000000POOL";
-	const creditManager = buildCreditManager({
-		address: "0x0000000000000000000000000000000000000CM1",
-		pool: poolAddress,
-		underlyingToken: underlyingTokenAddress,
-		collateralTokens: [
-			collateralTokenAddress,
-			underlyingTokenAddress,
-			targetTokenAddress,
-			deth
-		],
-		supportedTokens: {
-			[collateralTokenAddress]: true,
-			[underlyingTokenAddress]: true,
-			[targetTokenAddress]: true,
-			[deth]: true
-		},
-		liquidationThresholds: {
-			[collateralTokenAddress]: 9300n,
-			[targetTokenAddress]: 9300n,
-			[underlyingTokenAddress]: 9500n,
-			[deth]: 8800n
-		},
-		quotas: {
-			[targetTokenAddress]: buildQuota({
-				isActive: true,
-				limit: 5000000000000000000000n,
-				quotaIncreaseFee: 0n,
-				rate: 100n,
-				token: "0xe72b141df173b999ae7c1adcbf60cc9833ce56a8",
-				totalQuoted: 1708445825184283030000n
-			}),
-			[collateralTokenAddress]: buildQuota({
-				token: collateralTokenAddress,
-				rate: 0n,
-				limit: toBN("1000000", 18)
-			}),
-			[deth]: buildQuota({
-				isActive: true,
-				limit: 500000000000000000000n,
-				quotaIncreaseFee: 0n,
-				rate: 100n,
-				token: deth,
-				totalQuoted: 28666207338545540000n
-			})
-		},
-		isQuoted: (t) => t.toLowerCase() !== underlyingTokenAddress,
-		feeInterest: 2e3,
-		isPaused: false,
-		baseBorrowRate: 18991,
-		maxDebt: 250000000000000000000n,
-		minDebt: 10000000000000000000n,
-		availableToBorrow: 859640767327531138355n
-	});
-	const pools = { [poolAddress]: buildPool({
-		address: poolAddress,
-		chainId: 1,
-		network: "Mainnet",
-		underlyingToken: underlyingTokenAddress,
-		dieselToken: poolAddress,
-		isPaused: false,
-		version: 310,
-		expectedLiquidity: 5596004266940175413222n,
-		expectedLiquidityLimit: 6903325375622920584635n,
-		availableLiquidity: 1307321108682745171413n,
-		interestModel: {
-			interestModel: "0x12e6e5c6fe4b37576dd4052e03a97ee7b9c29e86",
-			U_1: 7000n,
-			U_2: 9200n,
-			R_base: 0n,
-			R_slope1: 113n,
-			R_slope2: 150n,
-			R_slope3: 1236n,
-			version: 310,
-			isBorrowingMoreU2Forbidden: true
-		}
-	}) };
-	const allPrices = { [poolAddress]: {
-		[collateralTokenAddress]: 347896889077n,
-		[targetTokenAddress]: 342474099875n,
-		[underlyingTokenAddress]: 320438727057n,
-		[deth]: 322630065873n
-	} };
-	const walletBalances = {
-		[underlyingTokenAddress]: 0n,
-		[collateralTokenAddress]: 6191758000000000000n,
-		[targetTokenAddress]: 0n
-	};
-	const apyList = {
-		apyList: {
-			[targetTokenAddress]: 24600,
-			[collateralTokenAddress]: 27612,
-			[deth]: 16600
-		},
-		extraCollateralAPYList: { [poolAddress]: { [targetTokenAddress]: {
-			address: targetTokenAddress,
-			pool: poolAddress,
-			symbol: "ETHPlus",
-			type: "relative",
-			value: 0
-		} } },
-		pointsList: {
-			[collateralTokenAddress]: {
-				symbol: "weETH",
-				address: "0xcd5fe23c85820f7b72d0926fc9b05b43e359b7ee",
-				debtRewards: void 0,
-				rewards: [{
-					name: "Ether.fi",
-					units: "points",
-					multiplier: 200n,
-					type: "etherfi"
-				}]
-			},
-			[deth]: {
-				address: "0x871ab8e36cae9af35c6a3488b049965233deb7ed",
-				debtRewards: void 0,
-				rewards: [{
-					name: "Makina",
-					units: "points",
-					multiplier: 36000n,
-					type: "makina"
-				}],
-				symbol: "DETH"
-			}
-		},
-		extraCollateralPointsList: {},
-		poolRewardsList: {},
-		tokenExtraRewardsList: {},
-		poolExternalAPYList: {},
-		poolExtraAPYList: {}
-	};
-	it("computes expected earnings for APY-only scenario", () => {
-		const result = getCMYouCanEarn({
-			creditManager,
-			pools,
-			strategy: {
-				id: "test-strategy",
-				tokenOutAddress: targetTokenAddress,
-				chainId: 1,
-				network: "Mainnet"
-			},
-			delayedPhantoms: {},
-			apyList,
-			tokensList: tokenDataList,
-			walletBalances,
-			nativeTokenAddress,
-			wrappedNativeTokenAddress,
-			allPrices,
-			slippage: 10,
-			quotaReserve: 500
-		});
-		expect(result.status).toEqual("ok");
-		expect(result.data?.info?.maxAPY).toEqual({
-			overallAPY: 7.392,
-			overallAPYBigInt: 73920n,
-			overallAPYStatus: "calculated"
-		});
-		expect(result.data?.earnings).toEqual({
-			earnings: 496914282513333354n,
-			earningsUSD: 1592305801450150145856n
-		});
-	});
-	it("computes expected earnings for APY and points scenario", () => {
-		const result = getCMYouCanEarn({
-			creditManager,
-			pools,
-			strategy: {
-				id: "test-strategy",
-				tokenOutAddress: collateralTokenAddress,
-				chainId: 1,
-				network: "Mainnet"
-			},
-			delayedPhantoms: {},
-			apyList,
-			tokensList: tokenDataList,
-			walletBalances,
-			nativeTokenAddress,
-			wrappedNativeTokenAddress,
-			allPrices,
-			slippage: 10,
-			quotaReserve: 500
-		});
-		expect(result.status).toEqual("ok");
-		expect(result.data?.info?.maxAPY).toEqual({
-			overallAPY: 11.233,
-			overallAPYBigInt: 112330n,
-			overallAPYStatus: "calculated"
-		});
-		expect(result.data?.earnings).toEqual({
-			earnings: 755118795383153892n,
-			earningsUSD: 2419693055693930817344n
-		});
-		expect(result.data?.points?.info).toEqual(apyList.pointsList?.[collateralTokenAddress] || {});
-		expect(result.data?.points).toEqual({
-			debtRates: {
-				rewards: [],
-				rates: []
-			},
-			info: apyList.pointsList?.[collateralTokenAddress] || {},
-			rates: [2454n]
-		});
-	});
-	it("computes expected earnings for points-only scenario", () => {
-		const result = getCMYouCanEarn({
-			creditManager,
-			pools,
-			strategy: {
-				id: "test-strategy",
-				tokenOutAddress: deth,
-				chainId: 1,
-				network: "Mainnet"
-			},
-			delayedPhantoms: {},
-			apyList,
-			tokensList: tokenDataList,
-			walletBalances,
-			nativeTokenAddress,
-			wrappedNativeTokenAddress,
-			allPrices,
-			slippage: 10,
-			quotaReserve: 500
-		});
-		expect(result.status).toEqual("ok");
-		expect(result.data?.info?.maxAPY).toEqual({
-			overallAPY: void 0,
-			overallAPYBigInt: void 0,
-			overallAPYStatus: "negativeForPoints"
-		});
-		expect(result.data?.earnings).toEqual({
-			earnings: null,
-			earningsUSD: null
-		});
-		expect(result.data?.points?.info).toEqual(apyList.pointsList?.[deth] || {});
-		expect(result.data?.points).toEqual({
-			debtRates: {
-				rewards: [],
-				rates: []
-			},
-			info: apyList.pointsList?.[deth] || {},
-			rates: [259920n]
-		});
-	});
-});
-//#endregion
-export {};

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

@@ -1,69 +0,0 @@
-import { PriceUtils } from "../../price-math.js";
-import { getSingleQuotaBorrowRate } from "../../apy/get-single-quota-borrow-rate.js";
-import { getFactorFromLeverage } from "../leverage/get-factor-from-leverage.js";
-import "../leverage/index.js";
-import { isStrategyCMDisabled } from "./is-strategy-cm-disabled.js";
-import { getStrategyPoints } from "../points/get-strategy-points.js";
-import { getStrategyMaxAPY } from "./get-strategy-max-apy.js";
-import { sortStrategyCMsByAvailability } from "../sort-strategy-cms-by-availability/sort-strategy-cms-by-availability.js";
-import "../sort-strategy-cms-by-availability/index.js";
-//#region src/common-utils/utils/strategies/strategy-info/get-strategy-info-core.ts
-const EMPTY_ADDRESS = "";
-const lc = (address) => address.toLowerCase();
-function getStrategyInfoCore({ strategy, creditManagers, source, apyListByNetwork, quotaReserve, slippage }) {
-	const strategyCMsList = Object.values(creditManagers || {});
-	if (strategyCMsList.length === 0) return void 0;
-	const targetTokenAddress = lc(strategy.tokenOutAddress);
-	const openableCMsList = strategyCMsList.filter((cm) => !isStrategyCMDisabled(cm, cm.quotas[targetTokenAddress]));
-	const pools = strategyCMsList.reduce((acc, cm) => {
-		const pool = source.getPool(cm.chainId, cm.pool);
-		if (pool) acc[cm.pool] = pool;
-		return acc;
-	}, {});
-	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, effectiveBaseRate = 0, effectiveQuotaRate = 0n } = getStrategyMaxAPY(targetTokenAddress, minCreditManager, apyListByNetwork, slippage, quotaReserve, strategy.maxLeverage) || {};
-	const underlyingPrice = source.getMarketPrices(minCreditManager?.chainId ?? strategy.chainId, minCreditManager?.pool || EMPTY_ADDRESS)?.[underlyingToken] || 0n;
-	const underlyingDecimals = source.getToken(strategy.chainId, underlyingToken)?.decimals || 18;
-	const availableToBorrowMoney = PriceUtils.calcTotalPrice(underlyingPrice, availableToBorrow, underlyingDecimals);
-	const r = BigInt(effectiveBaseRate) * getFactorFromLeverage(maxLeverage) / maxLeverage;
-	return {
-		maxLeverage,
-		maxAPY: totalMaxApy,
-		bonusAPY,
-		totalBorrowRate: Number(r + effectiveQuotaRate),
-		baseQuotaRateWithFee: getSingleQuotaBorrowRate({
-			quotaRates: minCreditManager?.quotas || {},
-			feeInterest: minCreditManager?.feeInterest || 0,
-			quotas: { [targetTokenAddress]: {
-				token: targetTokenAddress,
-				balance: 1n
-			} }
-		}),
-		availableToBorrowMoney,
-		minCreditManager,
-		points: getStrategyPoints({
-			strategy: {
-				chainId: strategy.chainId,
-				tokenOutAddress: targetTokenAddress
-			},
-			info: {
-				maxLeverage,
-				minCreditManager
-			},
-			strategyCreditManagers: creditManagers ?? {},
-			apyListByNetwork
-		})
-	};
-}
-//#endregion
-export { getStrategyInfoCore };