@gearbox-protocol/sdk 14.10.0 → 14.10.2-next.1

package/dist/esm/dev/claimFromFaucet.js

@@ -19,7 +19,8 @@ async function claimFromFaucet(opts) {
     role,
     amount,
     logger,
-    gasMultiplier = 10n
+    gasMultiplier = 10n,
+    sync = false
   } = opts;
   let amnt = "default amount";
   let args;
@@ -60,7 +61,8 @@ async function claimFromFaucet(opts) {
     functionName: "claim",
     args
   });
-  const hash = await wallet.writeContract({
+  logger?.debug({ gas }, "estimated claim tx gas");
+  const { request } = await publicClient.simulateContract({
     account: claimer,
     address: faucet,
     abi: faucetAbi,
@@ -69,15 +71,23 @@ async function claimFromFaucet(opts) {
     chain: wallet.chain,
     gas: gas * gasMultiplier
   });
-  const receipt = await publicClient.waitForTransactionReceipt({
-    hash
-  });
+  logger?.debug({ request }, "simulated claim tx request");
+  let receipt;
+  if (sync) {
+    receipt = await wallet.writeContractSync(request);
+  } else {
+    const hash = await wallet.writeContract(request);
+    logger?.debug({ hash }, "claim tx hash");
+    receipt = await publicClient.waitForTransactionReceipt({ hash });
+  }
   if (receipt.status === "reverted") {
     throw new Error(
-      `${usr} failed to claimed ${amnt} from faucet, tx: ${hash}`
+      `${usr} failed to claimed ${amnt} from faucet, tx: ${receipt.transactionHash}`
     );
   }
-  logger?.debug(`${usr} claimed ${amnt} from faucet, tx: ${hash}`);
+  logger?.debug(
+    `${usr} claimed ${amnt} from faucet, tx: ${receipt.transactionHash}`
+  );
 }
 export {
   claimFromFaucet

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/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/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/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/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/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 {};

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 { TokenData } from "../../../charts/token-data.js";
+import type { LocalDebtReward, LocalPointsInfo, LocalPointsReward } from "../types/points-slices.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, TokenData>;
+    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/get-cm-you-can-earn.d.ts

@@ -0,0 +1,19 @@
+import type { Address } from "viem";
+import type { TokenData } from "../../../charts/token-data.js";
+import type { Strategy } from "../types/strategy.js";
+import type { APYList, CreditManagerData, PoolData, PricesRecord } from "../types/strategy-data.js";
+import type { StrategyCMEarningsInfo } from "../types/strategy-earnings.js";
+export declare function getCMYouCanEarn<CM extends CreditManagerData>({ allPrices, creditManager, tokensList, delayedPhantoms, nativeTokenAddress, wrappedNativeTokenAddress, walletBalances, strategy, slippage, quotaReserve, apyList, pools, }: {
+    allPrices: PricesRecord | undefined;
+    creditManager: CM;
+    tokensList: Record<Address, TokenData>;
+    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}`, PoolData>;
+}): 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-you-can-earn.d.ts

@@ -0,0 +1,29 @@
+import type { Address } from "viem";
+import type { TokenData } from "../../../charts/token-data.js";
+import type { Strategy } from "../types/strategy.js";
+import type { APYList, CreditManagerData, PoolData, PricesRecord } from "../types/strategy-data.js";
+import type { StrategyCMEarningsInfo } from "../types/strategy-earnings.js";
+type EarningsList<CM extends CreditManagerData> = Array<StrategyCMEarningsInfo<CM>>;
+interface GearboxSDKFullState {
+    pools: Record<Address, PoolData> | undefined;
+    tokens: {
+        tokenDataList: Record<Address, TokenData>;
+    } | undefined;
+    addressProvider: {
+        wrappedNativeToken: Address | undefined;
+    };
+    withdrawableAssets: Record<Address, Array<{
+        withdrawalPhantomToken: Address;
+    }>> | undefined;
+}
+export declare function getStrategyYouCanEarn<CM extends CreditManagerData>({ 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/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 { TokenData } from "../../../charts/token-data.js";
+export declare function addAmountInTarget<T extends Asset>(asset: T, tokensList: Record<Address, TokenData>, 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 { TokenData } from "../../../charts/token-data.js";
+export interface AddAmountInTargetProps<T> {
+    assets: Array<T>;
+    targetToken: Address;
+    prices: Record<Address, bigint>;
+    tokensList: Record<Address, TokenData>;
+}
+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/is-apy-with-points-exception.d.ts

@@ -0,0 +1,3 @@
+import type { Address } from "viem";
+export declare const RST_ETH_ADDRESS: Address;
+export declare function isApyWithPointsException(token: Address | undefined): boolean;

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

@@ -0,0 +1,16 @@
+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];
+export interface IsCollateralTokenProps {
+    address: Address;
+    tokensList: Record<Address, TokenData>;
+    creditManager: CreditManagerData;
+    delayedPhantoms: Record<Address, boolean>;
+    extraCollateralConfigs: ExtraCollateralConfig[] | undefined;
+    prices: Record<Address, bigint> | undefined;
+    zeroDebt?: boolean;
+}
+export declare function isCollateralToken({ address, tokensList, creditManager, zeroDebt, delayedPhantoms, extraCollateralConfigs, prices, }: IsCollateralTokenProps): boolean;
+export {};

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

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

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

@@ -0,0 +1,14 @@
+import type { Address } from "viem";
+import type { QuotaInfo } from "../types/strategy-data.js";
+export interface IsObtainableTokenProps {
+    address: Address;
+    creditManager: {
+        quotas: Record<Address, QuotaInfo | undefined>;
+        isQuoted(token: Address): boolean;
+        forbiddenTokens: Record<Address, true>;
+        liquidationThresholds: Record<Address, bigint>;
+        supportedTokens: Record<Address, true>;
+    };
+    delayedPhantoms: Record<Address, boolean>;
+}
+export declare function isObtainableToken({ address, creditManager, delayedPhantoms, }: IsObtainableTokenProps): boolean;

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

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

package/dist/types/common-utils/utils/strategies/tokens/is-valid-extra-collateral-token.d.ts

@@ -0,0 +1,20 @@
+import type { Address } from "viem";
+export interface IsValidExtraCollateralTokenProps {
+    address: Address;
+    extraCollateralConfigs: Array<Address | {
+        token: Address;
+        cm: Address;
+    }> | undefined;
+    prices: Record<Address, bigint> | undefined;
+    creditManager: {
+        address: Address;
+        underlyingToken: Address;
+        forbiddenTokens: Record<Address, true>;
+    } | undefined;
+    tokensList: Record<Address, {
+        isPhantom: boolean;
+    }>;
+    delayedPhantoms: Record<Address, boolean>;
+    zeroDebt?: boolean;
+}
+export declare function isValidExtraCollateralToken({ address, extraCollateralConfigs, prices, creditManager, tokensList, delayedPhantoms, zeroDebt, }: IsValidExtraCollateralTokenProps): boolean;

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

@@ -0,0 +1,2 @@
+import type { Address } from "viem";
+export declare function wrapTokenAddress(tokenAddress: Address, nativeTokenAddress: Address, wrappedNativeTokenAddress: Address | undefined): `0x${string}`;

package/dist/types/common-utils/utils/strategies/tokens/wrap-token-address.spec.d.ts

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

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

@@ -1,4 +1,5 @@
-export type { QuotaSlice as QuotaInfo } from "../strategy-info/types.js";
+import type { QuotaSlice } from "../strategy-info/types.js";
+export type QuotaInfo = QuotaSlice;
 export * from "./chains.js";
 export * from "./credit-manager-data-legacy.js";
 export * from "./curator-filter.js";

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

@@ -0,0 +1,64 @@
+import type { Address } from "viem";
+import type { QuotaSlice } from "../strategy-info/types.js";
+import type { LocalPointsInfo } from "./points-slices.js";
+export type QuotaInfo = QuotaSlice;
+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 PoolData {
+    address: Address;
+    expectedLiquidity: bigint;
+    availableLiquidity: bigint;
+    interestModel: LinearModel;
+    totalDebtLimit: bigint;
+    totalBorrowed: bigint;
+    underlyingToken?: Address;
+    isPaused?: boolean;
+}
+export interface CreditManagerData {
+    address: Address;
+    name: string;
+    underlyingToken: Address;
+    pool: Address;
+    isPaused: boolean;
+    collateralTokens: Array<Address>;
+    forbiddenTokens: Record<Address, true>;
+    supportedTokens: Record<Address, true>;
+    quotas: Record<Address, QuotaInfo>;
+    liquidationThresholds: Record<Address, bigint>;
+    maxDebt: bigint;
+    minDebt: bigint;
+    availableToBorrow: bigint;
+    totalDebt: bigint;
+    totalDebtLimit: bigint;
+    feeInterest: number;
+    baseBorrowRate: number;
+    maxEnabledTokensLength: number;
+    chainId: number;
+    isDegenMode: boolean;
+    degenNFT: Address;
+    isQuoted(token: Address): boolean;
+    isForbidden(token: Address): boolean;
+}
+export interface PricesRecord {
+    [pool: Address]: {
+        [token: Address]: bigint;
+    };
+}
+export interface APYList {
+    apyList: Record<Address, number> | undefined;
+    extraCollateralAPYList: Record<Address, Record<Address, {
+        type: "relative" | "absolute";
+        value: number;
+    }>> | undefined;
+    pointsList: Record<Address, LocalPointsInfo> | undefined;
+    extraCollateralPointsList: Record<Address, Record<Address, LocalPointsInfo>> | undefined;
+}

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

@@ -0,0 +1,43 @@
+import type { Asset } from "../../../../sdk/router/types.js";
+import type { calculateEarnings } from "../../apy/calculate-earnings.js";
+import type { Strategy } from "../../strategies/types/strategy.js";
+import type { calculateTotalAPY } from "../strategy-info/calculate-total-apy.js";
+import type { calculateTotalPoints } from "../strategy-info/calculate-total-points.js";
+import type { getListWithAmountInTarget } from "../tokens/get-list-with-amount-in-target.js";
+import type { CreditManagerData } from "./strategy-data.js";
+export type StrategyCMEarningsInfo<CM extends CreditManagerData> = {
+    status: "ok";
+    description: string;
+    otherInfo?: object;
+    data: {
+        info: {
+            strategy: Strategy;
+            creditManager: CM;
+            collateral: Array<Asset>;
+            assetsWithAmountInTarget: ReturnType<typeof getListWithAmountInTarget>;
+            assetValue: bigint;
+            debt: bigint;
+            totalAmount: bigint;
+            assetValueInUSD: bigint;
+            maxAPY: ReturnType<typeof calculateTotalAPY>;
+            bonusAPY: {
+                value: number;
+            } | undefined;
+            maxLeverage: bigint;
+        };
+        earnings: ReturnType<typeof calculateEarnings>;
+        points: ReturnType<typeof calculateTotalPoints>;
+    };
+} | {
+    status: "error";
+    description: string;
+    otherInfo?: object;
+    data: undefined;
+};
+export type EarningsList<CM extends CreditManagerData> = Array<StrategyCMEarningsInfo<CM>>;
+export type StrategyEarningsListByChain<CM extends CreditManagerData> = Record<number, Record<string, EarningsList<CM>>>;
+export interface BestEarningsState<CM extends CreditManagerData> {
+    best: StrategyCMEarningsInfo<CM> | undefined;
+    sorted: StrategyCMEarningsInfo<CM>[];
+    bestRecord: Record<number, Record<Strategy["id"], StrategyCMEarningsInfo<CM>>>;
+}

package/dist/types/common-utils/utils/validation/is-zero-balance.d.ts

@@ -0,0 +1 @@
+export declare function isZeroBalance(balance: bigint | undefined): boolean;

package/dist/types/common-utils/utils/validation/validate-balance.d.ts

@@ -0,0 +1,22 @@
+import type { Address } from "viem";
+export interface ValidateBalanceProps {
+    amount: bigint;
+    tokenAddress: Address;
+    maxAmount: bigint | undefined;
+    zeroCheck?: boolean;
+    single?: boolean;
+}
+export type ValidateBalanceResult = {
+    message: "unknownToken";
+    token: Address;
+} | {
+    message: "insufficientFunds";
+    token: Address;
+} | {
+    message: "zeroBalance";
+    token: Address;
+} | {
+    message: "enterAmount";
+    token: Address;
+};
+export declare function validateBalance({ amount, tokenAddress, maxAmount, zeroCheck, single, }: ValidateBalanceProps): ValidateBalanceResult | null;

package/dist/types/common-utils/utils/validation/validate-balance.spec.d.ts

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

package/dist/types/common-utils/utils/validation/validate-balances.d.ts

@@ -0,0 +1,9 @@
+import type { Address } from "viem";
+import type { Asset } from "../../../sdk/router/types.js";
+import type { ValidateBalanceResult } from "./validate-balance.js";
+export interface ValidateBalancesProps {
+    balances: Record<Address, bigint>;
+    assets: Array<Asset>;
+    zeroCheck?: boolean;
+}
+export declare function validateBalances({ balances, assets, zeroCheck, }: ValidateBalancesProps): ValidateBalanceResult | null;

package/dist/types/common-utils/utils/validation/validate-balances.spec.d.ts

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