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

package/dist/esm/common-utils/utils/apy/calculate-safe-borrow-rate.spec.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { buildCreditManager, buildPool } from "../../test-utils/index.js";
+import { calculateSafeBorrowRate } from "./calculate-safe-borrow-rate.js";
+describe("calculateSafeBorrowRate", () => {
+  const baseModel = {
+    U_1: 50n,
+    U_2: 80n,
+    R_base: 100n,
+    R_slope1: 0n,
+    R_slope2: 0n,
+    R_slope3: 0n,
+    interestModel: "0x1",
+    isBorrowingMoreU2Forbidden: false,
+    version: 3
+  };
+  const poolBase = buildPool({
+    expectedLiquidity: 1000n,
+    availableLiquidity: 1000n,
+    // util = 0
+    interestModel: baseModel
+  });
+  it("returns rate with no fee at zero utilization", () => {
+    const creditManager = buildCreditManager({ feeInterest: 0 });
+    const rate = calculateSafeBorrowRate({
+      pool: poolBase,
+      creditManager
+    });
+    expect(rate).toBe(1e4);
+  });
+  it("applies feeInterest scaling", () => {
+    const creditManager = buildCreditManager({ feeInterest: 200 });
+    const rate = calculateSafeBorrowRate({
+      pool: poolBase,
+      creditManager
+    });
+    expect(rate).toBe(10200);
+  });
+});

package/dist/esm/common-utils/utils/apy/get-complex-apy-list.js

@@ -0,0 +1,21 @@
+import { TypedObjectUtils } from "../../../sdk/index.js";
+function getComplexAPYList(baseAPYList, extraCollateralAPYList, pool) {
+  if (!pool) return baseAPYList;
+  const poolExtraCollateralAPY = extraCollateralAPYList?.[pool];
+  if (!poolExtraCollateralAPY) return baseAPYList;
+  const baseCopy = { ...baseAPYList };
+  TypedObjectUtils.entries(poolExtraCollateralAPY).forEach(
+    ([token, extraAPY]) => {
+      const baseAPY = baseCopy[token];
+      if (extraAPY.type === "relative" && baseAPY !== void 0) {
+        baseCopy[token] = baseAPY + extraAPY.value;
+      } else if (extraAPY.type === "absolute") {
+        baseCopy[token] = extraAPY.value;
+      }
+    }
+  );
+  return baseCopy;
+}
+export {
+  getComplexAPYList
+};

package/dist/esm/common-utils/utils/apy/get-rate-with-fee.js

@@ -0,0 +1,7 @@
+import { PERCENTAGE_FACTOR, toBigInt } from "../../../sdk/index.js";
+function getRateWithFee(rate, feeInterest) {
+  return toBigInt(rate) * (BigInt(feeInterest) + PERCENTAGE_FACTOR) / PERCENTAGE_FACTOR;
+}
+export {
+  getRateWithFee
+};

package/dist/esm/common-utils/utils/apy/get-safe-base-borrow-rate.js

@@ -0,0 +1,16 @@
+import {
+  calculateSafeBorrowRate
+} from "./calculate-safe-borrow-rate.js";
+const getSafeBaseBorrowRate = (props) => {
+  const { onError, ...rest } = props;
+  try {
+    const rate = calculateSafeBorrowRate(rest);
+    return rate;
+  } catch (e) {
+    onError?.(e);
+    return void 0;
+  }
+};
+export {
+  getSafeBaseBorrowRate
+};

package/dist/esm/common-utils/utils/apy/get-single-quota-borrow-rate.js

@@ -0,0 +1,9 @@
+import { calcQuotaBorrowRate } from "../creditAccount/calc-quota-borrow-rate.js";
+import { getRateWithFee } from "./get-rate-with-fee.js";
+function getSingleQuotaBorrowRate(props) {
+  const qr = calcQuotaBorrowRate(props);
+  return getRateWithFee(qr, props.feeInterest);
+}
+export {
+  getSingleQuotaBorrowRate
+};

package/dist/esm/common-utils/utils/apy/index.js

@@ -0,0 +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/esm/common-utils/utils/apy/max-apy-formula.js

@@ -0,0 +1,16 @@
+import { LEVERAGE_DECIMALS } from "../../../sdk/index.js";
+import { getFactorFromLeverage } from "../strategies/leverage/index.js";
+function maxAPYFormula({
+  apy,
+  leverage,
+  baseRateWithFee,
+  quotaRateWithFee
+}) {
+  const collateralTerm = apy - quotaRateWithFee;
+  const leverageFactor = getFactorFromLeverage(leverage);
+  const debtTerm = (apy - baseRateWithFee - quotaRateWithFee) * Number(leverageFactor) / Number(LEVERAGE_DECIMALS);
+  return collateralTerm + Math.floor(debtTerm);
+}
+export {
+  maxAPYFormula
+};

package/dist/esm/common-utils/utils/constants.js

@@ -0,0 +1,8 @@
+const EMPTY_OBJECT = {};
+const EMPTY_ARRAY = [];
+const EMPTY_ADDRESS = "";
+export {
+  EMPTY_ADDRESS,
+  EMPTY_ARRAY,
+  EMPTY_OBJECT
+};

package/dist/esm/common-utils/utils/creditAccount/quota-utils.js

@@ -59,6 +59,7 @@ function calcQuotaUpdate(props) {
   };
   const desiredQuota = Object.values(quotas).reduce(
     (acc, cmQuota) => {
+      if (!cmQuota) return acc;
       const { token, isActive } = cmQuota;
       const { quota: initialQuota = 0n } = initialQuotas[token] || {};
       if (!isActive) {

package/dist/esm/common-utils/utils/index.js

@@ -1,4 +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/esm/common-utils/utils/strategies/assets/assets.js

@@ -0,0 +1,6 @@
+function getDefaultAsset(token) {
+  return { token };
+}
+export {
+  getDefaultAsset
+};

package/dist/esm/common-utils/utils/strategies/assets/index.js

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

package/dist/esm/common-utils/utils/strategies/availability/check-boolean.js

@@ -0,0 +1,9 @@
+function checkBoolean(a, b) {
+  if (a && b) return 0;
+  if (a) return -1;
+  if (b) return 1;
+  return 0;
+}
+export {
+  checkBoolean
+};

package/dist/esm/common-utils/utils/strategies/availability/check-degen-nft.js

@@ -0,0 +1,11 @@
+import { ADDRESS_0X0 } from "../../../../sdk/index.js";
+function checkDegenNFT(creditManager) {
+  const nftAddress = creditManager.isDegenMode ? creditManager.degenNFT : ADDRESS_0X0;
+  return {
+    nftAddress,
+    freeOfNFT: nftAddress === ADDRESS_0X0
+  };
+}
+export {
+  checkDegenNFT
+};

package/dist/esm/common-utils/utils/strategies/availability/index.js

@@ -0,0 +1,2 @@
+export * from "./check-boolean.js";
+export * from "./check-degen-nft.js";

package/dist/esm/common-utils/utils/strategies/credit-managers/get-cm-allowed-collaterals.js

@@ -0,0 +1,38 @@
+import { isCollateralToken } from "../tokens/is-collateral-token.js";
+function getCMAllowedCollaterals({
+  creditManager,
+  tokensList,
+  zeroDebt = false,
+  delayedPhantoms,
+  extraCollaterals,
+  nativeTokenAddress,
+  wrappedNativeTokenAddress
+}) {
+  const tokens = creditManager?.collateralTokens;
+  if (!tokens) return {};
+  const collateralRecord = tokens.reduce(
+    (acc, address) => {
+      const allowed = isCollateralToken({
+        address,
+        tokensList,
+        creditManager,
+        zeroDebt,
+        delayedPhantoms,
+        extraCollateralConfigs: extraCollaterals?.list?.[address],
+        prices: extraCollaterals?.prices
+      });
+      if (allowed) {
+        acc[address] = address;
+      }
+      return acc;
+    },
+    {}
+  );
+  if (!creditManager.isPaused && wrappedNativeTokenAddress && collateralRecord[wrappedNativeTokenAddress] && nativeTokenAddress) {
+    collateralRecord[nativeTokenAddress] = nativeTokenAddress;
+  }
+  return collateralRecord;
+}
+export {
+  getCMAllowedCollaterals
+};

package/dist/esm/common-utils/utils/strategies/credit-managers/get-cm-allowed-collaterals.spec.js

@@ -0,0 +1,115 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { TokenData } from "../../../charts/token-data.js";
+import {
+  buildCreditManager,
+  mockNativeTokenAddress,
+  mockToken1,
+  mockToken2,
+  mockUnderlyingToken,
+  mockWrappedNativeTokenAddress
+} from "../../../test-utils/index.js";
+import { isCollateralToken } from "../tokens/is-collateral-token.js";
+import { getCMAllowedCollaterals } from "./get-cm-allowed-collaterals.js";
+vi.mock("./is-collateral-token");
+const mockIsCollateralToken = vi.mocked(isCollateralToken);
+describe("getCMAllowedCollaterals", () => {
+  const underlying = mockUnderlyingToken;
+  const allowed = mockToken1;
+  const rejected = mockToken2;
+  const tokensList = {
+    [underlying]: new TokenData({
+      addr: underlying,
+      symbol: "DAI",
+      name: "Underlying",
+      decimals: 18,
+      isPhantom: false
+    }),
+    [allowed]: new TokenData({
+      addr: allowed,
+      symbol: "USDC",
+      name: "Allowed",
+      decimals: 6,
+      isPhantom: false
+    }),
+    [rejected]: new TokenData({
+      addr: rejected,
+      symbol: "WBTC",
+      name: "Rejected",
+      decimals: 8,
+      isPhantom: false
+    }),
+    [mockWrappedNativeTokenAddress]: new TokenData({
+      addr: mockWrappedNativeTokenAddress,
+      symbol: "WETH",
+      name: "WrappedNative",
+      decimals: 18,
+      isPhantom: false
+    })
+  };
+  const baseCm = buildCreditManager({
+    address: "0x0000000000000000000000000000000000000CAA",
+    underlyingToken: underlying,
+    collateralTokens: [
+      underlying,
+      allowed,
+      rejected,
+      mockWrappedNativeTokenAddress
+    ]
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  });
+  it("returns empty record when credit manager missing", () => {
+    const result = getCMAllowedCollaterals({
+      creditManager: void 0,
+      tokensList,
+      delayedPhantoms: {},
+      nativeTokenAddress: mockNativeTokenAddress,
+      wrappedNativeTokenAddress: mockWrappedNativeTokenAddress,
+      extraCollaterals: void 0
+    });
+    expect(result).toEqual({});
+  });
+  it("keeps allowed collaterals and mirrors wrapped native to native token", () => {
+    mockIsCollateralToken.mockImplementation(
+      ({ address }) => address !== rejected
+    );
+    const result = getCMAllowedCollaterals({
+      creditManager: baseCm,
+      tokensList,
+      delayedPhantoms: {},
+      nativeTokenAddress: mockNativeTokenAddress,
+      wrappedNativeTokenAddress: mockWrappedNativeTokenAddress,
+      extraCollaterals: void 0
+    });
+    expect(result).toEqual({
+      [underlying]: underlying,
+      [allowed]: allowed,
+      [mockWrappedNativeTokenAddress]: mockWrappedNativeTokenAddress,
+      [mockNativeTokenAddress]: mockNativeTokenAddress
+    });
+  });
+  it("does not mirror wrapped native when credit manager is paused", () => {
+    mockIsCollateralToken.mockReturnValue(true);
+    const pausedCm = buildCreditManager({
+      ...baseCm,
+      isPaused: true
+    });
+    const result = getCMAllowedCollaterals({
+      creditManager: pausedCm,
+      tokensList,
+      delayedPhantoms: {},
+      nativeTokenAddress: mockNativeTokenAddress,
+      wrappedNativeTokenAddress: mockWrappedNativeTokenAddress,
+      extraCollaterals: void 0
+    });
+    expect(result).toEqual({
+      [underlying]: underlying,
+      [allowed]: allowed,
+      [rejected]: rejected,
+      [mockWrappedNativeTokenAddress]: mockWrappedNativeTokenAddress
+    });
+    expect(result[mockNativeTokenAddress]).toBeUndefined();
+  });
+});

package/dist/esm/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers-list-core.js

@@ -0,0 +1,42 @@
+import { TypedObjectUtils } from "../../../../sdk/utils/mappers.js";
+import { isUsableToken } from "../tokens/index.js";
+import { isCreditManagerUsable } from "./is-credit-manager-usable.js";
+const lc = (address) => address.toLowerCase();
+function getStrategyCreditManagersListCore({
+  strategies,
+  source,
+  curatorFilter
+}) {
+  if (!strategies) return strategies;
+  return strategies.reduce((acc, strategy) => {
+    const targetToken = lc(strategy.tokenOutAddress);
+    const cms = (strategy.creditManagers || []).reduce(
+      (cmAcc, cmAddress) => {
+        const cm = source.getCreditManager(strategy.chainId, cmAddress);
+        if (!cm || !isCreditManagerUsable(cm)) return cmAcc;
+        const usable = isUsableToken({
+          address: targetToken,
+          creditManager: cm
+        });
+        const limit = cm.quotas[targetToken]?.limit || 0n;
+        const limitZero = targetToken === cm.underlyingToken ? false : limit === 0n;
+        if (usable && !cm.isBorrowingForbidden && !limitZero) {
+          cmAcc[cm.address] = cm;
+        }
+        return cmAcc;
+      },
+      {}
+    );
+    const cmsAfterCuratorFilter = curatorFilter ? TypedObjectUtils.entries(cms).filter(
+      ([, cm]) => curatorFilter[cm.marketConfigurator]
+    ) : TypedObjectUtils.entries(cms);
+    if (!acc[strategy.chainId]) acc[strategy.chainId] = {};
+    acc[strategy.chainId][strategy.id] = Object.fromEntries(
+      cmsAfterCuratorFilter
+    );
+    return acc;
+  }, {});
+}
+export {
+  getStrategyCreditManagersListCore
+};

package/dist/esm/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers-list.js

@@ -0,0 +1,13 @@
+import { createLegacyStrategyDataSource } from "../types.js";
+import { getStrategyCreditManagersListCore } from "./get-strategy-credit-managers-list-core.js";
+function getStrategyCreditManagersList(strategies, sdkStateByChain, curatorFilter) {
+  if (!sdkStateByChain) return sdkStateByChain;
+  return getStrategyCreditManagersListCore({
+    strategies,
+    source: createLegacyStrategyDataSource(sdkStateByChain),
+    curatorFilter
+  });
+}
+export {
+  getStrategyCreditManagersList
+};

package/dist/esm/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers.js

@@ -0,0 +1,28 @@
+import { isUsableToken } from "../tokens/is-usable-token.js";
+import { isCreditManagerUsable } from "./is-credit-manager-usable.js";
+const lc = (address) => address.toLowerCase();
+function getStrategyCreditManagers({ strategy, allCreditManagers }) {
+  const lpAddress = lc(strategy.tokenOutAddress);
+  const res = (strategy?.creditManagers || []).reduce(
+    (acc, cmAddress) => {
+      const cm = allCreditManagers[cmAddress] ?? allCreditManagers[lc(cmAddress)];
+      if (cm && isCreditManagerUsable(cm)) {
+        const usable = isUsableToken({
+          address: lpAddress,
+          creditManager: cm
+        });
+        const limit = cm.quotas[lpAddress]?.limit || 0n;
+        const limitZero = lpAddress === cm.underlyingToken ? false : limit === 0n;
+        if (usable && !cm.isBorrowingForbidden && !limitZero) {
+          acc[cm.address] = cm;
+        }
+      }
+      return acc;
+    },
+    {}
+  );
+  return res;
+}
+export {
+  getStrategyCreditManagers
+};

package/dist/esm/common-utils/utils/strategies/credit-managers/get-wallet-balances-allowed-on-cm.js

@@ -0,0 +1,51 @@
+import { sortBalances } from "../../creditAccount/sort.js";
+import { wrapTokenAddress } from "../tokens/wrap-token-address.js";
+function getWalletBalancesAllowedOnCM({
+  walletBalances,
+  collateralRecord,
+  nativeTokenAddress,
+  wrappedNativeTokenAddress,
+  prices,
+  tokensList,
+  isPaused = false
+}) {
+  const walletBalancesSorted = sortBalances(
+    walletBalances || {},
+    prices,
+    tokensList
+  );
+  const { list, record } = walletBalancesSorted.reduce(
+    (acc, [token, balance]) => {
+      if (isPaused && token === nativeTokenAddress) return acc;
+      const wrappedAddress = wrapTokenAddress(
+        token,
+        nativeTokenAddress,
+        wrappedNativeTokenAddress
+      );
+      if (collateralRecord[wrappedAddress]) {
+        const asset = {
+          token,
+          balance
+        };
+        acc.list.push(asset);
+        acc.record[wrappedAddress] = asset;
+      }
+      return acc;
+    },
+    { list: [], record: {} }
+  );
+  const collateralList = Object.values(collateralRecord);
+  const missingAssets = collateralList.filter(
+    (token) => isPaused ? token !== nativeTokenAddress && !record[token] : !record[token]
+  ).map(
+    (token) => ({
+      token,
+      balance: 0n
+    })
+  );
+  const r = [...list, ...missingAssets];
+  return r;
+}
+export {
+  getWalletBalancesAllowedOnCM
+};

package/dist/esm/common-utils/utils/strategies/credit-managers/get-wallet-balances-allowed-on-cm.spec.js

@@ -0,0 +1,96 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { TokenData } from "../../../charts/token-data.js";
+import {
+  mockNativeTokenAddress,
+  mockToken1,
+  mockWrappedNativeTokenAddress
+} from "../../../test-utils/index.js";
+import { sortBalances } from "../../creditAccount/sort.js";
+import { getWalletBalancesAllowedOnCM } from "./get-wallet-balances-allowed-on-cm.js";
+vi.mock("../../utils/creditAccount/sort.js", async () => {
+  const actual = await vi.importActual(
+    "../../utils/creditAccount/sort.js"
+  );
+  return {
+    ...actual,
+    sortBalances: vi.fn()
+  };
+});
+const mockSortBalances = vi.mocked(sortBalances);
+describe("getWalletBalancesAllowedOnCM", () => {
+  const allowed = mockToken1;
+  const prices = {};
+  const tokensList = {
+    [mockNativeTokenAddress]: new TokenData({
+      addr: mockNativeTokenAddress,
+      symbol: "ETH",
+      name: "Native",
+      decimals: 18,
+      isPhantom: false
+    }),
+    [mockWrappedNativeTokenAddress]: new TokenData({
+      addr: mockWrappedNativeTokenAddress,
+      symbol: "WETH",
+      name: "Wrapped",
+      decimals: 18,
+      isPhantom: false
+    }),
+    [allowed]: new TokenData({
+      addr: allowed,
+      symbol: "DAI",
+      name: "Allowed",
+      decimals: 18,
+      isPhantom: false
+    })
+  };
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  });
+  it("wraps native token when allowed and keeps sorted balances", () => {
+    const collateralRecord = {
+      [mockWrappedNativeTokenAddress]: mockWrappedNativeTokenAddress,
+      [allowed]: allowed
+    };
+    mockSortBalances.mockReturnValue([
+      [mockNativeTokenAddress, 2n],
+      [allowed, 1n]
+    ]);
+    const result = getWalletBalancesAllowedOnCM({
+      walletBalances: {
+        [mockNativeTokenAddress]: 2n,
+        [allowed]: 1n
+      },
+      collateralRecord,
+      nativeTokenAddress: mockNativeTokenAddress,
+      wrappedNativeTokenAddress: mockWrappedNativeTokenAddress,
+      prices,
+      tokensList
+    });
+    expect(result).toEqual([
+      { token: mockNativeTokenAddress, balance: 2n },
+      { token: allowed, balance: 1n }
+    ]);
+  });
+  it("skips native token when paused and fills missing collaterals with zero", () => {
+    const collateralRecord = {
+      [mockWrappedNativeTokenAddress]: mockWrappedNativeTokenAddress,
+      [allowed]: allowed,
+      [mockNativeTokenAddress]: mockNativeTokenAddress
+    };
+    mockSortBalances.mockReturnValue([[mockNativeTokenAddress, 5n]]);
+    const result = getWalletBalancesAllowedOnCM({
+      walletBalances: { [mockNativeTokenAddress]: 5n },
+      collateralRecord,
+      nativeTokenAddress: mockNativeTokenAddress,
+      wrappedNativeTokenAddress: mockWrappedNativeTokenAddress,
+      prices,
+      tokensList,
+      isPaused: true
+    });
+    expect(result).toEqual([
+      { token: mockWrappedNativeTokenAddress, balance: 0n },
+      { token: allowed, balance: 0n }
+    ]);
+  });
+});

package/dist/esm/common-utils/utils/strategies/credit-managers/index.js

@@ -0,0 +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/esm/common-utils/utils/strategies/credit-managers/is-credit-manager-usable.js

@@ -0,0 +1,7 @@
+import { isV310 } from "../../../../sdk/index.js";
+function isCreditManagerUsable(cm) {
+  return !cm.isBorrowingForbidden && isV310(cm.version);
+}
+export {
+  isCreditManagerUsable
+};

package/dist/esm/common-utils/utils/strategies/eligibility/index.js

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

package/dist/esm/common-utils/utils/strategies/eligibility/is-strategy-eligible.js

@@ -0,0 +1,22 @@
+const EMPTY_ADDRESS = "";
+function isStrategyEligible(s, allowedChains, showHiddenStrategies, sdkStateByChain, curatorFilter) {
+  const network = s?.chainId !== void 0 ? allowedChains[s.chainId] : void 0;
+  const isNetworkCorrect = !!network && network === s.network;
+  const isHidden = !showHiddenStrategies && s.hideInProd;
+  const networkConditionMet = isNetworkCorrect && !isHidden;
+  const tokensList = sdkStateByChain?.[s.chainId]?.tokens?.tokenDataList;
+  const targetToken = tokensList?.[s?.tokenOutAddress || EMPTY_ADDRESS];
+  const isTokensCorrect = !!targetToken;
+  const showInMainApp = s.showInMainApp ?? true;
+  const showCondition = curatorFilter || showInMainApp;
+  return networkConditionMet && isTokensCorrect && showCondition ? {
+    isEligible: true,
+    network
+  } : {
+    isEligible: false,
+    network: void 0
+  };
+}
+export {
+  isStrategyEligible
+};

package/dist/esm/common-utils/utils/strategies/eligibility/is-strategy-released.js

@@ -0,0 +1,7 @@
+function isStrategyReleased(releaseAt, currentTimestamp) {
+  if (releaseAt === void 0) return true;
+  return currentTimestamp > releaseAt;
+}
+export {
+  isStrategyReleased
+};

package/dist/esm/common-utils/utils/strategies/index.js

@@ -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/esm/common-utils/utils/strategies/leverage/calculate-loss-coefficient.js

@@ -0,0 +1,7 @@
+import { SLIPPAGE_DECIMALS, toBigInt } from "../../../../sdk/index.js";
+function calculateLossCoefficient(slippage, constantLoss = 30n) {
+  return 100n * SLIPPAGE_DECIMALS - toBigInt(slippage) - constantLoss;
+}
+export {
+  calculateLossCoefficient
+};