@gearbox-protocol/sdk 15.0.0-next.2 → 15.0.0-pyth.1

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

@@ -0,0 +1,2 @@
+export * from "./is-strategy-eligible.js";
+export * from "./is-strategy-released.js";

package/dist/types/common-utils/utils/strategies/eligibility/is-strategy-eligible.d.ts

@@ -0,0 +1,8 @@
+import type { AppChains, CuratorFilter, GearboxSDKFullState, NotValidatedStrategy, StrategyCreditManagerView } from "../types.js";
+export declare function isStrategyEligible<CM extends StrategyCreditManagerView>(s: Pick<NotValidatedStrategy, "chainId" | "network" | "hideInProd" | "tokenOutAddress" | "showInMainApp">, allowedChains: AppChains, showHiddenStrategies: boolean, sdkStateByChain: Record<number, Pick<GearboxSDKFullState<CM>, "tokens"> | undefined> | undefined, curatorFilter: CuratorFilter): {
+    readonly isEligible: true;
+    readonly network: "Mainnet" | "Arbitrum" | "Optimism" | "Base" | "Sonic" | "MegaETH" | "Monad" | "Berachain" | "Avalanche" | "BNB" | "WorldChain" | "Etherlink" | "Hemi" | "Lisk" | "Plasma" | "Somnia";
+} | {
+    readonly isEligible: false;
+    readonly network: undefined;
+};

package/dist/types/common-utils/utils/strategies/eligibility/is-strategy-released.d.ts

@@ -0,0 +1 @@
+export declare function isStrategyReleased(releaseAt: undefined | number, currentTimestamp: number): boolean;

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

@@ -0,0 +1,12 @@
+export * from "./assets/index.js";
+export * from "./availability/index.js";
+export * from "./credit-managers/index.js";
+export * from "./eligibility/index.js";
+export * from "./leverage/index.js";
+export * from "./lists/index.js";
+export * from "./points/index.js";
+export * from "./sort-strategy-cms-by-availability/index.js";
+export * from "./strategy-info/index.js";
+export * from "./strategy-state/index.js";
+export * from "./tokens/index.js";
+export * from "./types.js";

package/dist/types/common-utils/utils/strategies/leverage/calculate-loss-coefficient.d.ts

@@ -0,0 +1 @@
+export declare function calculateLossCoefficient(slippage: number, constantLoss?: bigint): bigint;

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

@@ -0,0 +1,12 @@
+import type { Address } from "viem";
+import type { LeverageFactor } from "./get-factor-from-leverage.js";
+export declare function calculateMaxLeverageFactor({ targetToken, slippage, creditManagers, constantLoss, leverageLimit, }: {
+    targetToken: Address;
+    slippage: number;
+    creditManagers: Array<{
+        liquidationThresholds: Record<Address, bigint>;
+        address: Address;
+    }>;
+    constantLoss?: bigint;
+    leverageLimit?: number;
+}): LeverageFactor;

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 { CreditManagerSlice } from "../strategy-info/types.js";
+export interface CalculateMaxDebtProps {
+    targetToken: Address;
+    amount: bigint;
+    creditManager: CreditManagerSlice;
+    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-factor-from-leverage.d.ts

@@ -0,0 +1,4 @@
+export type LeverageFactor = bigint & {
+    __brand: "leverageFactor";
+};
+export declare function getFactorFromLeverage(leverage: bigint): bigint;

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

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

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

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+import type { CreditManagerSlice } from "../strategy-info/types.js";
+import type { LeverageFactor } from "./get-factor-from-leverage.js";
+export interface GetRecommendedDebtProps {
+    targetToken: Address;
+    amount: bigint;
+    creditManager: CreditManagerSlice;
+    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

@@ -0,0 +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/leverage/max-leverage-threshold.d.ts

@@ -0,0 +1,5 @@
+import type { Address } from "viem";
+export declare function maxLeverageThreshold(lpToken: Address, cms: Array<{
+    liquidationThresholds: Record<Address, bigint>;
+    address: Address;
+}>): readonly [bigint, Address];

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

@@ -0,0 +1,9 @@
+import type { Address } from "viem";
+/**
+ * Max leverage factor (not leverage value) for a token across CMs.
+ * Returns a factor where leverage = factor + LEVERAGE_DECIMALS.
+ */
+export declare function maxLeverage(lpToken: Address, cms: Array<{
+    liquidationThresholds: Record<Address, bigint>;
+    address: Address;
+}>, targetHF?: bigint): bigint;

package/dist/types/common-utils/utils/strategies/lists/get-available-and-disabled-strategies.d.ts

@@ -0,0 +1,7 @@
+import type { CuratorFilter, StrategiesCMListByChain, Strategy, StrategyCreditManagerView } from "../types.js";
+export declare function getAvailableAndDisabledStrategies<CM extends StrategyCreditManagerView>(list: Strategy[] | undefined | undefined, listCMs: StrategiesCMListByChain<CM> | undefined, curatorFilter: CuratorFilter | undefined): {
+    available: Error | import("../types.js").StrategyRecord | null;
+    disabled: import("../types.js").StrategyRecord;
+    availableList: Error | Strategy[] | null;
+    disabledList: Strategy[];
+};

package/dist/types/common-utils/utils/strategies/lists/get-available-strategies.d.ts

@@ -0,0 +1,5 @@
+import type { StrategiesCMListByChain, Strategy, StrategyCreditManagerView, StrategyRecord } from "../types.js";
+export declare function getAvailableStrategies<CM extends StrategyCreditManagerView>(list: Strategy[] | undefined | undefined, listCMs: StrategiesCMListByChain<CM> | undefined): {
+    record: StrategyRecord | null | Error;
+    list: Array<Strategy> | null | Error;
+};

package/dist/types/common-utils/utils/strategies/lists/get-disabled-strategies.d.ts

@@ -0,0 +1,5 @@
+import type { CuratorFilter, StrategiesCMListByChain, Strategy, StrategyCreditManagerView, StrategyRecord } from "../types.js";
+export declare function getDisabledStrategies<CM extends StrategyCreditManagerView>(list: Strategy[] | undefined | undefined, listCMs: StrategiesCMListByChain<CM> | undefined, curatorFilter: CuratorFilter | undefined): {
+    record: StrategyRecord;
+    list: Array<Strategy>;
+};

package/dist/types/common-utils/utils/strategies/lists/get-released-strategies-list-core.d.ts

@@ -0,0 +1,9 @@
+import type { AppChains, CuratorFilter, NotValidatedStrategy, Strategy, StrategyDataSource } from "../types.js";
+export interface GetReleasedStrategiesListCoreArgs {
+    strategyPayloadsList: NotValidatedStrategy[] | undefined;
+    allowedChains: AppChains | undefined;
+    source: StrategyDataSource;
+    curatorFilter: CuratorFilter;
+    showHiddenStrategies: boolean;
+}
+export declare function getReleasedStrategiesListCore({ strategyPayloadsList, allowedChains, source, curatorFilter, showHiddenStrategies, }: GetReleasedStrategiesListCoreArgs): Strategy[] | undefined;

package/dist/types/common-utils/utils/strategies/lists/get-released-strategies-list.d.ts

@@ -0,0 +1,2 @@
+import type { AppChains, CuratorFilter, GearboxSDKFullStateByChain, NotValidatedStrategy, StrategyCreditManagerView } from "../types.js";
+export declare function getReleasedStrategiesList<CM extends StrategyCreditManagerView>(strategyPayloadsList: NotValidatedStrategy[] | undefined, allowedChains: AppChains | undefined, sdkStateByChain: GearboxSDKFullStateByChain<CM> | undefined, curatorFilter: CuratorFilter, showHiddenStrategies: boolean): import("../types.js").Strategy[] | undefined;

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

@@ -0,0 +1,3 @@
+export * from "./get-available-and-disabled-strategies.js";
+export * from "./get-released-strategies-list.js";
+export * from "./get-released-strategies-list-core.js";

package/dist/types/common-utils/utils/strategies/points/get-complex-points-list.d.ts

@@ -0,0 +1,3 @@
+import type { Address } from "viem";
+import type { LocalPointsInfo } from "../types.js";
+export declare function getComplexPointsList<T extends Address | undefined = undefined>(baseList: Record<Address, LocalPointsInfo> | undefined, extraList: Record<Address, Record<Address, LocalPointsInfo>> | undefined, pool: T | undefined): Record<Address, LocalPointsInfo> | undefined;

package/dist/types/common-utils/utils/strategies/points/get-points-info.d.ts

@@ -0,0 +1,8 @@
+import type { Address } from "viem";
+import type { LocalPointsInfo, PointsList, StrategyCreditManagerLike } from "../types.js";
+export declare function getPointsInfo({ chainId, pointsList, token, creditManagers, }: {
+    chainId: number | undefined;
+    pointsList: PointsList | undefined;
+    token: Address | undefined;
+    creditManagers: Record<Address, StrategyCreditManagerLike> | undefined;
+}): LocalPointsInfo | undefined;

package/dist/types/common-utils/utils/strategies/points/get-points-rates.d.ts

@@ -0,0 +1,2 @@
+import type { LocalPointsReward } from "../types.js";
+export declare function getPointsRates(rewards: Array<Pick<LocalPointsReward, "multiplier">>, leverage: bigint): (bigint | "soon")[];

package/dist/types/common-utils/utils/strategies/points/get-strategy-points.d.ts

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+import type { APYListByNetwork, StrategyCreditManagerLike, StrategyInfoLike } from "../types.js";
+export interface StrategyLike {
+    chainId: number;
+    tokenOutAddress: Address;
+}
+export interface GetStrategyPointsProps {
+    readonly strategy: StrategyLike;
+    readonly info: StrategyInfoLike | undefined;
+    readonly strategyCreditManagers: Record<Address, StrategyCreditManagerLike>;
+    readonly apyListByNetwork: APYListByNetwork | undefined;
+}
+export declare function getStrategyPoints({ strategy, info, strategyCreditManagers, apyListByNetwork, }: GetStrategyPointsProps): {
+    pointsInfo: import("../types.js").LocalPointsInfo | undefined;
+    pointsInfoDebt: import("../types.js").LocalPointsInfo | undefined;
+    rewards: import("../../../../rewards/index.js").PointsReward<string>[];
+    debtRewards: import("../../../../rewards/index.js").DebtReward<string>[];
+    rewardRates: (bigint | "soon")[];
+    debtRewardRates: (bigint | "soon")[];
+};
+export type StrategyPointsResult = ReturnType<typeof getStrategyPoints>;

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

@@ -0,0 +1,4 @@
+export * from "./get-complex-points-list.js";
+export * from "./get-points-info.js";
+export * from "./get-points-rates.js";
+export * from "./get-strategy-points.js";

package/dist/types/common-utils/utils/strategies/sort-strategy-cms-by-availability/index.d.ts

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

package/dist/types/common-utils/utils/strategies/sort-strategy-cms-by-availability/sort-strategy-cms-by-availability.d.ts

@@ -0,0 +1,28 @@
+import type { Address } from "viem";
+import { type APYListSlice, type CreditManagerSlice, type PoolSlice } from "../strategy-info/index.js";
+export interface SortStrategyCMsByAvailabilityProps {
+    targetToken: Address;
+    allCreditManagers: Array<CreditManagerSlice>;
+    apyListByNetwork: Record<number, APYListSlice | undefined> | undefined;
+    pools: Record<Address, PoolSlice> | undefined | null;
+    slippage: number;
+    quotaReserve: number;
+    leverageLimit: number | undefined;
+    isStrategy: boolean;
+}
+/**
+ * CMs sorted by availability (debt, quota, apy)
+ */
+export type SortedCMs<T extends CreditManagerSlice> = Array<T> & {
+    __brand: "availability";
+};
+export declare function sortStrategyCMsByAvailability<CM extends CreditManagerSlice>({ targetToken, allCreditManagers, apyListByNetwork, pools, slippage, quotaReserve, leverageLimit, isStrategy, }: {
+    targetToken: Address;
+    allCreditManagers: Array<CM>;
+    apyListByNetwork: Record<number, APYListSlice | undefined> | undefined;
+    pools: Record<Address, PoolSlice> | undefined | null;
+    slippage: number;
+    quotaReserve: number;
+    leverageLimit: number | undefined;
+    isStrategy: boolean;
+}): SortedCMs<CM>;

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

@@ -0,0 +1,27 @@
+import type { Address } from "viem";
+import type { Asset } from "../../../../sdk/router/types.js";
+import type { QuotaSlice, TokenSlice } from "./types.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<QuotaSlice, "isActive" | "rate"> | undefined>;
+    quotas: Record<Address, Asset>;
+    feeInterest: number;
+    underlyingToken: Address;
+    tokensList: Record<Address, TokenSlice>;
+}
+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 {};

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

@@ -0,0 +1,22 @@
+import type { Address } from "viem";
+import type { Asset } from "../../../../sdk/router/types.js";
+import type { LocalDebtReward, LocalPointsInfo, LocalPointsReward } from "../types/points-slices.js";
+import type { TokenSlice } from "./types.js";
+export interface PointsData {
+    rates: Array<LocalPointsReward["multiplier"]>;
+    debtRates: {
+        rewards: Array<LocalDebtReward>;
+        rates: Array<LocalDebtReward["multiplier"]>;
+    };
+    info: LocalPointsInfo;
+}
+export declare function calculateTotalPoints({ pointsAsset, cmAddress, info, totalValue, assetValue, prices, tokensList, underlyingToken, }: {
+    pointsAsset: Asset | undefined;
+    cmAddress: Address;
+    info: LocalPointsInfo | undefined;
+    totalValue: bigint | undefined;
+    assetValue: bigint | undefined;
+    prices: Record<Address, bigint>;
+    tokensList: Record<Address, TokenSlice>;
+    underlyingToken: Address;
+}): PointsData | null;

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

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

package/dist/types/common-utils/utils/strategies/strategy-info/cm-availability-condition.d.ts

@@ -0,0 +1,3 @@
+import type { Address } from "viem";
+import type { CreditManagerSlice, PoolSlice } from "./types.js";
+export declare function cmAvailabilityCondition(targetToken: Address, cmA: CreditManagerSlice, cmB: CreditManagerSlice, pools: Record<Address, PoolSlice> | null | undefined): number;

package/dist/types/common-utils/utils/strategies/strategy-info/get-cm-you-can-earn.d.ts

@@ -0,0 +1,19 @@
+import type { Address } from "viem";
+import type { CreditManagerSlice, PoolSlice, TokenSlice } from "../strategy-info/types.js";
+import type { Strategy } from "../types/strategy.js";
+import type { APYList, PricesRecord } from "../types/strategy-data.js";
+import type { StrategyCMEarningsInfo } from "../types/strategy-earnings.js";
+export declare function getCMYouCanEarn<CM extends CreditManagerSlice>({ allPrices, creditManager, tokensList, delayedPhantoms, nativeTokenAddress, wrappedNativeTokenAddress, walletBalances, strategy, slippage, quotaReserve, apyList, pools, }: {
+    allPrices: PricesRecord | undefined;
+    creditManager: CM;
+    tokensList: Record<Address, TokenSlice>;
+    delayedPhantoms: Record<Address, boolean>;
+    nativeTokenAddress: Address;
+    wrappedNativeTokenAddress: Address | undefined;
+    walletBalances: Record<`0x${string}`, bigint> | undefined;
+    strategy: Strategy;
+    slippage: number;
+    quotaReserve: number;
+    apyList: APYList | undefined;
+    pools: Record<`0x${string}`, PoolSlice>;
+}): StrategyCMEarningsInfo<CM>;

package/dist/types/common-utils/utils/strategies/strategy-info/get-cm-you-can-earn.spec.d.ts

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

package/dist/types/common-utils/utils/strategies/strategy-info/get-strategy-info-core.d.ts

@@ -0,0 +1,16 @@
+import type { Address } from "viem";
+import type { StrategyDataSource } from "../types/index.js";
+import type { BasePointsList, ExtraCollateralPointsList } from "../types.js";
+import type { APYListSlice, CreditManagerSlice, StrategyInfoResult, StrategySlice } from "./types.js";
+export interface GetStrategyInfoCoreArgs<ID extends string | number, CM extends CreditManagerSlice> {
+    strategy: StrategySlice<ID>;
+    creditManagers: Record<Address, CM> | undefined;
+    source: StrategyDataSource;
+    apyListByNetwork: Record<number, (APYListSlice & {
+        pointsList?: BasePointsList;
+        extraCollateralPointsList?: ExtraCollateralPointsList;
+    }) | undefined> | undefined;
+    quotaReserve: number;
+    slippage: number;
+}
+export declare function getStrategyInfoCore<ID extends string | number, CM extends CreditManagerSlice>({ strategy, creditManagers, source, apyListByNetwork, quotaReserve, slippage, }: GetStrategyInfoCoreArgs<ID, CM>): StrategyInfoResult<CM> | undefined;

package/dist/types/common-utils/utils/strategies/strategy-info/get-strategy-info.d.ts

@@ -0,0 +1,2 @@
+import type { CreditManagerSlice, GetStrategyInfoArgs, StrategyInfoResult } from "./types.js";
+export declare function getStrategyInfo<ID extends string | number, CM extends CreditManagerSlice = CreditManagerSlice>({ strategy, creditManagers, sdkStateByChain, apyListByNetwork, quotaReserve, slippage, allPricesByChain, }: GetStrategyInfoArgs<ID, CM>): StrategyInfoResult<CM> | undefined;

package/dist/types/common-utils/utils/strategies/strategy-info/get-strategy-max-apy.d.ts

@@ -0,0 +1,15 @@
+import type { Address } from "viem";
+import type { APYListSlice, CreditManagerSlice } from "./types.js";
+type CMForStrategyMaxAPY = Pick<CreditManagerSlice, "chainId" | "pool" | "underlyingToken" | "baseBorrowRate" | "liquidationThresholds" | "feeInterest" | "quotas" | "address">;
+export declare function getStrategyMaxAPY(targetToken: Address, cm: CMForStrategyMaxAPY | undefined, apyListByNetwork: Record<number, APYListSlice | undefined> | undefined, slippage: number, quotaReserve: number, leverageLimit: number | undefined): {
+    totalMaxApy: number;
+    bonusAPY: {
+        value: number;
+    } | undefined;
+    maxAPY: number;
+    maxLeverage: bigint;
+    effectiveBaseRate: number;
+    effectiveQuotaRate: bigint;
+    totalBorrowRate: number;
+} | undefined;
+export {};

package/dist/types/common-utils/utils/strategies/strategy-info/get-strategy-you-can-earn.d.ts

@@ -0,0 +1,29 @@
+import type { Address } from "viem";
+import type { CreditManagerSlice, PoolSlice, TokenSlice } from "../strategy-info/types.js";
+import type { Strategy } from "../types/strategy.js";
+import type { APYList, PricesRecord } from "../types/strategy-data.js";
+import type { StrategyCMEarningsInfo } from "../types/strategy-earnings.js";
+type EarningsList<CM extends CreditManagerSlice> = Array<StrategyCMEarningsInfo<CM>>;
+interface GearboxSDKFullState {
+    pools: Record<Address, PoolSlice> | undefined;
+    tokens: {
+        tokenDataList: Record<Address, TokenSlice>;
+    } | undefined;
+    addressProvider: {
+        wrappedNativeToken: Address | undefined;
+    };
+    withdrawableAssets: Record<Address, Array<{
+        withdrawalPhantomToken: Address;
+    }>> | undefined;
+}
+export declare function getStrategyYouCanEarn<CM extends CreditManagerSlice>({ strategy, creditManagers, sdkState, apyList, quotaReserve, slippage, allPrices, walletBalances, }: {
+    strategy: Strategy;
+    creditManagers: Record<Address, CM> | undefined;
+    sdkState: GearboxSDKFullState | undefined;
+    apyList: APYList | undefined;
+    allPrices: PricesRecord | undefined;
+    walletBalances: Record<`0x${string}`, bigint> | undefined;
+    quotaReserve: number;
+    slippage: number;
+}): EarningsList<CM>;
+export {};

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

@@ -0,0 +1,10 @@
+export * from "./calculate-total-apy.js";
+export * from "./calculate-total-points.js";
+export * from "./cm-availability-condition.js";
+export * from "./get-cm-you-can-earn.js";
+export * from "./get-strategy-info.js";
+export * from "./get-strategy-info-core.js";
+export * from "./get-strategy-max-apy.js";
+export * from "./get-strategy-you-can-earn.js";
+export * from "./is-strategy-cm-disabled.js";
+export * from "./types.js";

package/dist/types/common-utils/utils/strategies/strategy-info/is-strategy-cm-disabled.d.ts

@@ -0,0 +1,2 @@
+import type { CreditManagerSlice, QuotaSlice } from "./types.js";
+export declare function isStrategyCMDisabled(cm: Pick<CreditManagerSlice, "availableToBorrow" | "minDebt">, quota: Pick<QuotaSlice, "isActive" | "limit" | "totalQuoted"> | undefined): boolean;

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

@@ -0,0 +1,109 @@
+import type { Address } from "viem";
+import type { PartialRecord } from "../../../../sdk/index.js";
+import type { StrategyPointsResult } from "../points/get-strategy-points.js";
+export interface LinearModel {
+    U_1: bigint;
+    U_2: bigint;
+    R_base: bigint;
+    R_slope1: bigint;
+    R_slope2: bigint;
+    R_slope3: bigint;
+    interestModel: Address;
+    version: number;
+    isBorrowingMoreU2Forbidden: boolean;
+}
+export interface QuotaSlice {
+    token: Address;
+    rate: bigint;
+    quotaIncreaseFee: bigint;
+    totalQuoted: bigint;
+    limit: bigint;
+    isActive: boolean;
+}
+export interface CreditManagerSlice {
+    address: Address;
+    underlyingToken: Address;
+    pool: Address;
+    chainId: number;
+    baseBorrowRate: number;
+    feeInterest: number;
+    availableToBorrow: bigint;
+    minDebt: bigint;
+    maxDebt: bigint;
+    totalDebt: bigint;
+    totalDebtLimit: bigint;
+    isDegenMode: boolean;
+    degenNFT: Address;
+    liquidationThresholds: Record<Address, bigint>;
+    quotas: Record<Address, QuotaSlice | undefined>;
+    collateralTokens: readonly Address[];
+    maxEnabledTokensLength: number;
+    name: string;
+    isPaused: boolean;
+    supportedTokens: Record<Address, true>;
+    forbiddenTokens: Record<Address, true>;
+    isQuoted(token: Address): boolean;
+    isForbidden(token: Address): boolean;
+}
+export interface PoolSlice {
+    address: Address;
+    totalDebtLimit: bigint;
+    totalBorrowed: bigint;
+    expectedLiquidity: bigint;
+    availableLiquidity: bigint;
+    interestModel: LinearModel;
+    underlyingToken?: Address;
+    isPaused?: boolean;
+}
+export interface TokenSlice {
+    address: Address;
+    decimals: number;
+    title?: string;
+    symbol: string;
+    name?: string;
+    isPhantom?: boolean;
+}
+export interface StrategySlice<ID extends string | number = string> {
+    id: ID;
+    chainId: number;
+    tokenOutAddress: Address;
+    maxLeverage?: number;
+}
+export interface APYListSlice {
+    apyList: Record<Address, number> | undefined;
+    extraCollateralAPYList: Record<Address, Record<Address, {
+        type: "relative" | "absolute";
+        value: number;
+    }>> | undefined;
+}
+export interface PricesByChainSlice {
+    [chainId: number]: {
+        prices?: Record<Address, Record<Address, bigint>> | undefined;
+    } | undefined;
+}
+export interface StrategyInfoResult<CM extends CreditManagerSlice = CreditManagerSlice> {
+    maxLeverage: bigint;
+    maxAPY: number | undefined;
+    bonusAPY: {
+        value: number;
+    } | undefined;
+    totalBorrowRate: number;
+    availableToBorrowMoney: bigint;
+    minCreditManager: CM;
+    baseQuotaRateWithFee: bigint;
+    points?: StrategyPointsResult;
+}
+export interface GetStrategyInfoArgs<ID extends string | number, CM extends CreditManagerSlice> {
+    strategy: StrategySlice<ID>;
+    creditManagers: Record<number, PartialRecord<ID, Record<Address, CM>>> | undefined;
+    sdkStateByChain: Record<number, {
+        pools?: Record<Address, PoolSlice> | undefined;
+        tokens?: {
+            tokenDataList?: Record<Address, TokenSlice> | undefined;
+        };
+    } | undefined> | undefined;
+    apyListByNetwork: Record<number, APYListSlice | undefined> | undefined;
+    quotaReserve: number;
+    slippage: number;
+    allPricesByChain: PricesByChainSlice;
+}

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

@@ -0,0 +1 @@
+export * from "./is-strategy-disabled.js";

package/dist/types/common-utils/utils/strategies/strategy-state/is-strategy-disabled.d.ts

@@ -0,0 +1,3 @@
+import type { Address } from "viem";
+import type { StrategyCreditManagerView } from "../types.js";
+export declare function isStrategyDisabled(tokenOutAddress: Address, cms: Array<Pick<StrategyCreditManagerView, "quotas" | "availableToBorrow" | "minDebt">>): boolean;

package/dist/types/common-utils/utils/strategies/tokens/add-amount-in-target.d.ts

@@ -0,0 +1,6 @@
+import type { Address } from "viem";
+import type { Asset } from "../../../../sdk/router/types.js";
+import type { TokenSlice } from "../strategy-info/types.js";
+export declare function addAmountInTarget<T extends Asset>(asset: T, tokensList: Record<Address, TokenSlice>, prices: Record<Address, bigint>, toPrice: bigint, toDecimals: number): T & {
+    amountInTarget: bigint;
+};

package/dist/types/common-utils/utils/strategies/tokens/add-amount-in-target.spec.d.ts

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

package/dist/types/common-utils/utils/strategies/tokens/get-chain-phantom-tokens.d.ts

@@ -0,0 +1,6 @@
+import type { Address } from "viem";
+interface WithdrawableAssetClient {
+    withdrawalPhantomToken: Address;
+}
+export declare function getChainPhantomTokens(config: Record<Address, WithdrawableAssetClient[]> | undefined): Record<`0x${string}`, boolean>;
+export {};

package/dist/types/common-utils/utils/strategies/tokens/get-list-with-amount-in-target.d.ts

@@ -0,0 +1,12 @@
+import type { Address } from "viem";
+import type { Asset } from "../../../../sdk/router/types.js";
+import type { TokenSlice } from "../strategy-info/types.js";
+export interface AddAmountInTargetProps<T> {
+    assets: Array<T>;
+    targetToken: Address;
+    prices: Record<Address, bigint>;
+    tokensList: Record<Address, TokenSlice>;
+}
+export declare function getListWithAmountInTarget<T extends Asset>({ assets, targetToken, prices, tokensList, }: AddAmountInTargetProps<T>): Array<T & {
+    amountInTarget: bigint;
+}>;

package/dist/types/common-utils/utils/strategies/tokens/get-list-with-amount-in-target.spec.d.ts

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

package/dist/types/common-utils/utils/strategies/tokens/get-native-token-address.d.ts

@@ -0,0 +1 @@
+export declare function getNativeTokenAddress(): `0x${string}`;

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

@@ -0,0 +1,12 @@
+export * from "./add-amount-in-target.js";
+export * from "./get-chain-phantom-tokens.js";
+export * from "./get-list-with-amount-in-target.js";
+export * from "./get-native-token-address.js";
+export * from "./is-activated-token.js";
+export * from "./is-apy-with-points-exception.js";
+export * from "./is-collateral-token.js";
+export * from "./is-forbidden-token.js";
+export * from "./is-obtainable-token.js";
+export * from "./is-usable-token.js";
+export * from "./is-valid-extra-collateral-token.js";
+export * from "./wrap-token-address.js";

package/dist/types/common-utils/utils/strategies/tokens/is-activated-token.d.ts

@@ -0,0 +1,6 @@
+import type { Address } from "viem";
+import type { StrategyCreditManagerView } from "../types.js";
+export declare function isActivatedToken({ address, creditManager, }: {
+    address: Address;
+    creditManager: Pick<StrategyCreditManagerView, "liquidationThresholds" | "quotas" | "supportedTokens">;
+}): boolean;