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

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

@@ -1,5 +1,7 @@
-import { BigIntMath } from "../../bigint-math.js";
-import { validateOpenAccountPoolQuotaStatus } from "./validate-open-account-pool-quota-status.js";
+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);

package/dist/esm/common-utils/utils/validation/validate-open-account-pool-status.spec.js

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildCreditManager,
+  buildPool,
+  buildQuota,
+  mockToken1
+} from "../../test-utils/index.js";
+import { validateOpenAccountPoolStatus } from "./validate-open-account-pool-status.js";
+const mockCreditManager = buildCreditManager({
+  minDebt: 1000n,
+  maxDebt: 1000000n,
+  totalDebtLimit: 5000000n,
+  totalDebt: 2000000n,
+  availableToBorrow: 3000000n,
+  quotas: {
+    [mockToken1]: buildQuota({
+      token: mockToken1,
+      limit: 1000000n,
+      totalQuoted: 500000n,
+      rate: 0n
+    })
+  }
+});
+const mockPool = buildPool({
+  totalDebtLimit: 10000000n,
+  totalBorrowed: 5000000n
+});
+describe("validateOpenAccountPoolStatus", () => {
+  it("returns null when all conditions are met", () => {
+    const result = validateOpenAccountPoolStatus({
+      debt: 50000n,
+      creditManager: mockCreditManager,
+      pool: mockPool,
+      targetToken: mockToken1
+    });
+    expect(result).toBeNull();
+  });
+  it("returns error when debt exceeds debt limit", () => {
+    const result = validateOpenAccountPoolStatus({
+      debt: 4000000n,
+      creditManager: mockCreditManager,
+      pool: mockPool,
+      targetToken: mockToken1
+    });
+    expect(result).toEqual({
+      message: "insufficientDebtLimit",
+      amount: 3000000n,
+      solutionAmount: 3000000n
+    });
+  });
+  it("returns error when debt exceeds pool debt limit", () => {
+    const result = validateOpenAccountPoolStatus({
+      debt: 6000000n,
+      creditManager: buildCreditManager({
+        ...mockCreditManager,
+        totalDebtLimit: -1n
+      }),
+      pool: mockPool,
+      targetToken: mockToken1
+    });
+    expect(result).toEqual({
+      message: "insufficientPoolDebtLimit",
+      amount: 5000000n
+    });
+  });
+  it("returns error when debt exceeds available liquidity", () => {
+    const result = validateOpenAccountPoolStatus({
+      debt: 4000000n,
+      creditManager: buildCreditManager({
+        ...mockCreditManager,
+        totalDebtLimit: -1n
+      }),
+      pool: buildPool({ totalDebtLimit: -1n }),
+      targetToken: mockToken1
+    });
+    expect(result).toEqual({
+      message: "insufficientPoolLiquidity",
+      amount: 3000000n
+    });
+  });
+  it("returns error when quota is insufficient", () => {
+    const result = validateOpenAccountPoolStatus({
+      debt: 600000n,
+      creditManager: mockCreditManager,
+      pool: mockPool,
+      targetToken: mockToken1
+    });
+    expect(result).toEqual({
+      message: "insufficientQuota",
+      token: mockToken1
+    });
+  });
+  it("returns null when targetToken is null", () => {
+    const result = validateOpenAccountPoolStatus({
+      debt: 50000n,
+      creditManager: mockCreditManager,
+      pool: mockPool,
+      targetToken: null
+    });
+    expect(result).toBeNull();
+  });
+});

package/dist/esm/common-utils/utils/validation/validate-open-account.js

@@ -0,0 +1,17 @@
+import { validateQuota } from "./validate-quota.js";
+function validateOpenAccount(props) {
+  const { debt, creditManager, loading } = props;
+  if (loading) {
+    return { message: "loading" };
+  }
+  if (debt < creditManager.minDebt) {
+    return { message: "amountLessMin", amount: creditManager.minDebt };
+  }
+  if (debt > creditManager.maxDebt) {
+    return { message: "debtGreaterMax", amount: creditManager.maxDebt };
+  }
+  return validateQuota(props);
+}
+export {
+  validateOpenAccount
+};

package/dist/esm/common-utils/utils/validation/validate-open-account.spec.js

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildCreditManager,
+  mockUnderlyingToken
+} from "../../test-utils/index.js";
+import { validateOpenAccount } from "./validate-open-account.js";
+const mockCreditManager = buildCreditManager({
+  minDebt: 1000n,
+  maxDebt: 1000000n,
+  underlyingToken: mockUnderlyingToken
+});
+describe("validateOpenAccount", () => {
+  it("returns null when all conditions are met", () => {
+    const result = validateOpenAccount({
+      debt: 50000n,
+      creditManager: mockCreditManager,
+      desiredQuota: {},
+      quotaUpdate: []
+    });
+    expect(result).toBeNull();
+  });
+  it("returns loading error when loading is true", () => {
+    const result = validateOpenAccount({
+      debt: 50000n,
+      creditManager: mockCreditManager,
+      desiredQuota: {},
+      quotaUpdate: [],
+      loading: true
+    });
+    expect(result).toEqual({ message: "loading" });
+  });
+  it("returns error when debt is less than min", () => {
+    const result = validateOpenAccount({
+      debt: 500n,
+      creditManager: mockCreditManager,
+      desiredQuota: {},
+      quotaUpdate: []
+    });
+    expect(result).toEqual({
+      message: "amountLessMin",
+      amount: 1000n
+    });
+  });
+  it("returns error when debt is greater than max", () => {
+    const result = validateOpenAccount({
+      debt: 2000000n,
+      creditManager: mockCreditManager,
+      desiredQuota: {},
+      quotaUpdate: []
+    });
+    expect(result).toEqual({
+      message: "debtGreaterMax",
+      amount: 1000000n
+    });
+  });
+});

package/dist/esm/common-utils/utils/validation/validate-quota.js

@@ -0,0 +1,25 @@
+function validateQuota(props) {
+  const desiredQuotasList = Object.values(props.desiredQuota).filter(
+    (a) => a.balance > 0n
+  );
+  if (desiredQuotasList.length > props.creditManager.maxEnabledTokensLength)
+    return {
+      message: "maxQuotasLengthReached",
+      count: desiredQuotasList.length,
+      max: props.creditManager.maxEnabledTokensLength
+    };
+  if (props.quotaUpdate.length === 0 && props.throwOnZeroQuotaUpdate)
+    return { message: "quotaShouldBeUpdated" };
+  for (const { token, balance: updateBy } of props.quotaUpdate) {
+    const quota = props.creditManager.quotas[token];
+    if (updateBy > 0 && quota) {
+      const realLimit = quota.isActive ? quota.limit : 0n;
+      const quotaLeft = realLimit - quota.totalQuoted;
+      if (quotaLeft < updateBy) return { message: "insufficientQuota", token };
+    }
+  }
+  return null;
+}
+export {
+  validateQuota
+};

package/dist/esm/common-utils/utils/validation/validate-quota.spec.js

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildCreditManager,
+  buildQuota,
+  mockToken1,
+  mockToken2
+} from "../../test-utils/index.js";
+import { validateQuota } from "./validate-quota.js";
+const mockCreditManager = buildCreditManager({
+  minDebt: 1000n,
+  maxDebt: 1000000n,
+  totalDebtLimit: 5000000n,
+  totalDebt: 2000000n,
+  availableToBorrow: 3000000n,
+  quotas: {
+    [mockToken1]: buildQuota({
+      token: mockToken1,
+      limit: 1000000n,
+      totalQuoted: 500000n,
+      rate: 0n
+    }),
+    [mockToken2]: buildQuota({
+      token: mockToken2,
+      limit: 2000000n,
+      totalQuoted: 1000000n,
+      rate: 0n
+    })
+  },
+  maxEnabledTokensLength: 2
+});
+describe("validateQuota", () => {
+  it("returns null when all conditions are met", () => {
+    const result = validateQuota({
+      desiredQuota: {},
+      quotaUpdate: [],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: false
+    });
+    expect(result).toBeNull();
+  });
+  it("returns error when max quotas length is reached", () => {
+    const result = validateQuota({
+      desiredQuota: {
+        [mockToken1]: { token: mockToken1, balance: 1000n },
+        [mockToken2]: { token: mockToken2, balance: 1000n }
+      },
+      quotaUpdate: [],
+      creditManager: buildCreditManager({
+        ...mockCreditManager,
+        maxEnabledTokensLength: 1
+      }),
+      throwOnZeroQuotaUpdate: false
+    });
+    expect(result).toEqual({
+      message: "maxQuotasLengthReached",
+      count: 2,
+      max: 1
+    });
+  });
+  it("returns error when quota update is empty and throwOnZeroQuotaUpdate is true", () => {
+    const result = validateQuota({
+      desiredQuota: {},
+      quotaUpdate: [],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: true
+    });
+    expect(result).toEqual({
+      message: "quotaShouldBeUpdated"
+    });
+  });
+  it("returns error when quota is insufficient", () => {
+    const result = validateQuota({
+      desiredQuota: {},
+      quotaUpdate: [{ token: mockToken1, balance: 600000n }],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: false
+    });
+    expect(result).toEqual({
+      message: "insufficientQuota",
+      token: mockToken1
+    });
+  });
+});

package/dist/esm/common-utils/utils/validation/validate-token-to-obtain.js

@@ -0,0 +1,18 @@
+function validateTokenToObtain({
+  creditManager,
+  targetToken
+}) {
+  if (Array.isArray(targetToken)) {
+    for (const asset of targetToken) {
+      if (creditManager.forbiddenTokens[asset.token])
+        return { message: "tokenIsForbidden", token: asset.token };
+    }
+    return null;
+  }
+  if (targetToken !== null && creditManager.forbiddenTokens[targetToken])
+    return { message: "tokenIsForbidden", token: targetToken };
+  return null;
+}
+export {
+  validateTokenToObtain
+};

package/dist/esm/common-utils/utils/validation/validate-token-to-obtain.spec.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { buildCreditManager, mockToken1 } from "../../test-utils/index.js";
+import { validateTokenToObtain } from "./validate-token-to-obtain.js";
+const mockCreditManager = buildCreditManager({
+  forbiddenTokens: {}
+});
+describe("validateTokenToObtain", () => {
+  it("returns null when targetToken is null", () => {
+    const result = validateTokenToObtain({
+      targetToken: null,
+      creditManager: mockCreditManager
+    });
+    expect(result).toBeNull();
+  });
+  it("returns null when targetToken is not forbidden", () => {
+    const result = validateTokenToObtain({
+      targetToken: mockToken1,
+      creditManager: mockCreditManager
+    });
+    expect(result).toBeNull();
+  });
+  it("returns error when targetToken is forbidden", () => {
+    const result = validateTokenToObtain({
+      targetToken: mockToken1,
+      creditManager: buildCreditManager({
+        ...mockCreditManager,
+        forbiddenTokens: {
+          [mockToken1]: true
+        }
+      })
+    });
+    expect(result).toEqual({ message: "tokenIsForbidden", token: mockToken1 });
+  });
+});

package/dist/esm/plugins/apy/strategy-data-source.js

@@ -121,6 +121,7 @@ class OnchainSdkStrategyDataSource {
       liquidationThresholds,
       quotas,
       collateralTokens: cm.collateralTokens.map(lc),
+      maxEnabledTokensLength: cm.maxEnabledTokens,
       version: Number(facade.version),
       isBorrowingForbidden: facade.maxDebtPerBlockMultiplier === 0,
       marketConfigurator: lc(cs.marketConfigurator),

package/dist/esm/sdk/constants/math.js

@@ -14,6 +14,7 @@ const PRICE_DECIMALS = 10n ** BigInt(PRICE_DECIMALS_POW);
 const SECONDS_PER_YEAR = 365 * 24 * 3600;
 const PERCENTAGE_DECIMALS = 100n;
 const PERCENTAGE_FACTOR = 10000n;
+const PERCENTAGE_FACTOR_1KK = PERCENTAGE_FACTOR * PERCENTAGE_DECIMALS;
 const LEVERAGE_DECIMALS = 100n;
 const SLIPPAGE_DECIMALS = 100n;
 export {
@@ -24,6 +25,7 @@ export {
   MIN_INT96,
   PERCENTAGE_DECIMALS,
   PERCENTAGE_FACTOR,
+  PERCENTAGE_FACTOR_1KK,
   PRICE_DECIMALS,
   PRICE_DECIMALS_POW,
   RAY,

package/dist/types/common-utils/test-utils/index.d.ts

@@ -0,0 +1,16 @@
+import type { Address } from "viem";
+import { TokenData } from "../charts/token-data.js";
+export declare const mockToken1: Address;
+export declare const mockToken2: Address;
+export declare const mockUnderlyingToken: Address;
+export declare const mockNativeTokenAddress: Address;
+export declare const mockWrappedNativeTokenAddress: Address;
+export declare const mockCMAddress: Address;
+export declare function buildQuota(overrides: Record<string, unknown> & {
+    token: Address;
+}): any;
+export declare function buildPool(overrides?: Record<string, unknown>): any;
+export declare function buildCreditManager(overrides?: Record<string, unknown>): any;
+export declare function buildTokenData(address: Address, symbol: string, decimals?: number, isPhantom?: boolean): TokenData;
+export declare const mockTokenData: Record<Address, TokenData>;
+export declare const mockPrices: Record<Address, bigint>;

package/dist/types/common-utils/utils/apy/calculate-borrow-rate-from-utilization.d.ts

@@ -0,0 +1,2 @@
+import type { LinearModel } from "../strategies/types/strategy-data.js";
+export declare function calculateBorrowRateFromUtilization(util: bigint, model: LinearModel, extraPrecision?: bigint): bigint;

package/dist/types/common-utils/utils/apy/calculate-borrow-rate-from-utilization.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/common-utils/utils/apy/calculate-earnings.d.ts

@@ -0,0 +1,16 @@
+import type { Address } from "viem";
+import type { TokenData } from "../../charts/token-data.js";
+export interface CalculateEarningsProps {
+    overallAPYBigInt: bigint | undefined | null;
+    targetAmount: bigint | undefined;
+    targetToken: Address;
+    tokensList: Record<Address, TokenData>;
+    prices: Record<Address, bigint>;
+}
+export declare function calculateEarnings({ overallAPYBigInt, targetAmount, targetToken, tokensList, prices, }: CalculateEarningsProps): {
+    earnings: null;
+    earningsUSD: null;
+} | {
+    earnings: bigint;
+    earningsUSD: bigint;
+};

package/dist/types/common-utils/utils/apy/calculate-earnings.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/common-utils/utils/apy/calculate-safe-borrow-rate.d.ts

@@ -0,0 +1,11 @@
+import type { CreditManagerData, PoolData } from "../strategies/types/strategy-data.js";
+export interface CalculateBorrowRateSafelyProps {
+    pool: PoolData;
+    creditManager: CreditManagerData;
+    expectedLiquidityChange?: bigint;
+    availableLiquidityChange?: bigint;
+}
+/**
+ * Returns borrow rate multiplied by feeInterest
+ */
+export declare function calculateSafeBorrowRate({ pool, creditManager, expectedLiquidityChange, availableLiquidityChange, }: CalculateBorrowRateSafelyProps): number;

package/dist/types/common-utils/utils/apy/calculate-safe-borrow-rate.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/common-utils/utils/apy/get-safe-base-borrow-rate.d.ts

@@ -0,0 +1,4 @@
+import { type CalculateBorrowRateSafelyProps } from "./calculate-safe-borrow-rate.js";
+export declare const getSafeBaseBorrowRate: (props: CalculateBorrowRateSafelyProps & {
+    onError?: (error: unknown) => void;
+}) => number | undefined;

package/dist/types/common-utils/utils/apy/index.d.ts

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

package/dist/types/common-utils/utils/constants.d.ts

@@ -0,0 +1,4 @@
+import type { Address } from "viem";
+export declare const EMPTY_OBJECT: {};
+export declare const EMPTY_ARRAY: Array<never>;
+export declare const EMPTY_ADDRESS: Address;

package/dist/types/common-utils/utils/index.d.ts

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

package/dist/types/common-utils/utils/strategies/assets/assets.d.ts

@@ -0,0 +1,3 @@
+import type { Address } from "viem";
+import type { Asset } from "../../../../sdk/router/types.js";
+export declare function getDefaultAsset(token: Address): Omit<Asset, "balance">;

package/dist/types/common-utils/utils/strategies/assets/index.d.ts

@@ -0,0 +1 @@
+export * from "./assets.js";

package/dist/types/common-utils/utils/strategies/availability/index.d.ts

@@ -1,4 +1,2 @@
 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/types/common-utils/utils/strategies/credit-managers/get-cm-allowed-collaterals.d.ts

@@ -0,0 +1,20 @@
+import type { Address } from "viem";
+import type { TokenData } from "../../../charts/token-data.js";
+import type { StrategyConfigPayload } from "../../../static/strategy.js";
+import type { CreditManagerData } from "../types/strategy-data.js";
+type ExtraCollateralConfig = NonNullable<StrategyConfigPayload["additionalCollaterals"]>[number];
+type ExtraCollaterals = Record<Address, Array<ExtraCollateralConfig>>;
+export interface GetCMAllowedCollateralsProps {
+    creditManager: CreditManagerData | undefined;
+    tokensList: Record<Address, TokenData>;
+    zeroDebt?: boolean;
+    delayedPhantoms: Record<Address, boolean>;
+    extraCollaterals: {
+        list: ExtraCollaterals | undefined;
+        prices: Record<Address, bigint> | undefined;
+    } | undefined;
+    nativeTokenAddress: Address;
+    wrappedNativeTokenAddress: Address | undefined;
+}
+export declare function getCMAllowedCollaterals({ creditManager, tokensList, zeroDebt, delayedPhantoms, extraCollaterals, nativeTokenAddress, wrappedNativeTokenAddress, }: GetCMAllowedCollateralsProps): Record<Address, Address>;
+export {};

package/dist/types/common-utils/utils/strategies/credit-managers/get-cm-allowed-collaterals.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/common-utils/utils/strategies/credit-managers/get-wallet-balances-allowed-on-cm.d.ts

@@ -0,0 +1,13 @@
+import type { Address } from "viem";
+import type { Asset } from "../../../../sdk/router/types.js";
+import type { TokenData } from "../../../charts/token-data.js";
+export interface GetWalletBalancesAllowedOnCMProps {
+    walletBalances: Record<Address, bigint> | undefined;
+    collateralRecord: Record<Address, Address>;
+    tokensList: Record<Address, TokenData>;
+    prices: Record<Address, bigint>;
+    nativeTokenAddress: Address;
+    wrappedNativeTokenAddress: Address | undefined;
+    isPaused?: boolean;
+}
+export declare function getWalletBalancesAllowedOnCM({ walletBalances, collateralRecord, nativeTokenAddress, wrappedNativeTokenAddress, prices, tokensList, isPaused, }: GetWalletBalancesAllowedOnCMProps): Asset[];

package/dist/types/common-utils/utils/strategies/credit-managers/get-wallet-balances-allowed-on-cm.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/common-utils/utils/strategies/credit-managers/index.d.ts

@@ -1,4 +1,6 @@
+export * from "./get-cm-allowed-collaterals.js";
 export * from "./get-strategy-credit-managers.js";
 export * from "./get-strategy-credit-managers-list.js";
 export * from "./get-strategy-credit-managers-list-core.js";
+export * from "./get-wallet-balances-allowed-on-cm.js";
 export * from "./is-credit-manager-usable.js";

package/dist/types/common-utils/utils/strategies/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./assets/index.js";
 export * from "./availability/index.js";
 export * from "./credit-managers/index.js";
 export * from "./eligibility/index.js";

package/dist/types/common-utils/utils/strategies/leverage/calculate-max-strategy-debt.d.ts

@@ -0,0 +1,11 @@
+import type { Address } from "viem";
+import type { CreditManagerData } from "../types/strategy-data.js";
+export interface CalculateMaxDebtProps {
+    targetToken: Address;
+    amount: bigint;
+    creditManager: CreditManagerData;
+    slippage: number;
+    constantLoss?: bigint;
+    swapCollateral?: boolean;
+}
+export declare function calculateMaxStrategyDebt({ targetToken, amount, creditManager, slippage, constantLoss, swapCollateral, }: CalculateMaxDebtProps): bigint;

package/dist/types/common-utils/utils/strategies/leverage/calculate-max-strategy-debt.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/common-utils/utils/strategies/leverage/get-collateral-by-debt.d.ts

@@ -0,0 +1,2 @@
+export declare function getCollateralByDebt(debt: bigint, lt: bigint, // 1
+targetHF?: bigint): bigint;

package/dist/types/common-utils/utils/strategies/leverage/get-collateral-by-debt.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/common-utils/utils/strategies/leverage/get-recommended-debt.d.ts

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+import type { CreditManagerData } from "../types/strategy-data.js";
+import type { LeverageFactor } from "./get-factor-from-leverage.js";
+export interface GetRecommendedDebtProps {
+    targetToken: Address;
+    amount: bigint;
+    creditManager: CreditManagerData;
+    slippage: number;
+    maxLeverageConstantLoss?: bigint;
+    maxDebtConstantLoss?: bigint;
+    recommendedDebtConstantLoss?: bigint;
+    swapCollateral?: boolean;
+    leverageLimit: number | undefined;
+}
+export declare function getRecommendedDebt({ targetToken, amount, creditManager, slippage, maxLeverageConstantLoss, maxDebtConstantLoss, recommendedDebtConstantLoss, swapCollateral, leverageLimit, }: GetRecommendedDebtProps): {
+    maxDebt: bigint;
+    recommended: {
+        factor: LeverageFactor;
+        debt: bigint;
+    };
+};

package/dist/types/common-utils/utils/strategies/leverage/get-recommended-debt.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/common-utils/utils/strategies/leverage/get-recommended-leverage-factor.d.ts

@@ -0,0 +1,4 @@
+import type { LeverageFactor } from "./get-factor-from-leverage.js";
+export declare function getRecommendedLeverageFactor({ maxLeverageFactor, }: {
+    maxLeverageFactor: LeverageFactor;
+}): LeverageFactor;

package/dist/types/common-utils/utils/strategies/leverage/get-recommended-leverage-factor.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/common-utils/utils/strategies/leverage/index.d.ts

@@ -1,6 +1,10 @@
 export * from "./calculate-loss-coefficient.js";
 export * from "./calculate-max-leverage-factor.js";
+export * from "./calculate-max-strategy-debt.js";
+export * from "./get-collateral-by-debt.js";
 export * from "./get-factor-from-leverage.js";
 export * from "./get-leverage-from-factor.js";
+export * from "./get-recommended-debt.js";
+export * from "./get-recommended-leverage-factor.js";
 export * from "./max-leverage.js";
 export * from "./max-leverage-threshold.js";

package/dist/types/common-utils/utils/strategies/strategy-info/calculate-total-apy.d.ts

@@ -0,0 +1,28 @@
+import type { Address } from "viem";
+import type { Asset } from "../../../../sdk/router/types.js";
+import type { TokenData } from "../../../charts/token-data.js";
+import type { QuotaInfo } from "../types/strategy-data.js";
+export interface TotalAPY {
+    overallAPY: number | undefined | null;
+    overallAPYBigInt: bigint | undefined | null;
+    overallAPYStatus: "loading" | "notEnoughFarmAssets" | "noAPY" | "calculated" | "pointsNoAPY" | "negativeForPoints";
+}
+export interface CalculateTotalAPYProps {
+    caAssets: Asset[];
+    lpAPY: Record<Address, number> | undefined;
+    pointsInfo: Pick<{
+        address: Address;
+    }, "address"> | undefined;
+    isValueTo?: boolean;
+    debt: bigint | undefined;
+    totalValue: bigint | undefined;
+    effectiveBorrowRate: number;
+    showAPY: boolean;
+    prices: Record<Address, bigint>;
+    quotaRates: Record<Address, Pick<QuotaInfo, "isActive" | "rate">>;
+    quotas: Record<Address, Asset>;
+    feeInterest: number;
+    underlyingToken: Address;
+    tokensList: Record<Address, TokenData>;
+}
+export declare function calculateTotalAPY({ caAssets, lpAPY, pointsInfo, isValueTo, debt, totalValue, effectiveBorrowRate, showAPY, prices, quotaRates, quotas, feeInterest, underlyingToken, tokensList, }: CalculateTotalAPYProps): Omit<TotalAPY, "extraAPY">;

package/dist/types/common-utils/utils/strategies/strategy-info/calculate-total-apy.spec.d.ts

@@ -0,0 +1 @@
+export {};