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

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

@@ -0,0 +1,106 @@
+import { getSingleQuotaBorrowRate } from "../../index.js";
+import { PriceUtils } from "../../price-math.js";
+import { getFactorFromLeverage } from "../leverage/index.js";
+import { getStrategyPoints } from "../points/get-strategy-points.js";
+import { sortStrategyCMsByAvailability } from "../sort-strategy-cms-by-availability/index.js";
+import { getStrategyMaxAPY } from "./get-strategy-max-apy.js";
+import { isStrategyCMDisabled } from "./is-strategy-cm-disabled.js";
+const EMPTY_ADDRESS = "";
+const lc = (address) => address.toLowerCase();
+function getStrategyInfoCore({
+  strategy,
+  creditManagers,
+  source,
+  apyListByNetwork,
+  quotaReserve,
+  slippage
+}) {
+  const strategyCMsList = Object.values(creditManagers || {});
+  if (strategyCMsList.length === 0) return void 0;
+  const targetTokenAddress = lc(strategy.tokenOutAddress);
+  const openableCMsList = strategyCMsList.filter(
+    (cm) => !isStrategyCMDisabled(cm, cm.quotas[targetTokenAddress])
+  );
+  const pools = strategyCMsList.reduce(
+    (acc, cm) => {
+      const pool = source.getPool(cm.chainId, cm.pool);
+      if (pool) acc[cm.pool] = pool;
+      return acc;
+    },
+    {}
+  );
+  const minCreditManager = sortStrategyCMsByAvailability({
+    targetToken: targetTokenAddress,
+    allCreditManagers: openableCMsList.length > 0 ? openableCMsList : strategyCMsList,
+    apyListByNetwork,
+    slippage,
+    quotaReserve,
+    pools,
+    leverageLimit: strategy.maxLeverage,
+    isStrategy: true
+  })?.[0] || strategyCMsList[0];
+  const { underlyingToken = EMPTY_ADDRESS, availableToBorrow = 0n } = minCreditManager || {};
+  const {
+    bonusAPY,
+    totalMaxApy = 0,
+    maxLeverage = 0n,
+    effectiveBaseRate = 0,
+    effectiveQuotaRate = 0n
+  } = getStrategyMaxAPY(
+    targetTokenAddress,
+    minCreditManager,
+    apyListByNetwork,
+    slippage,
+    quotaReserve,
+    strategy.maxLeverage
+  ) || {};
+  const prices = source.getMarketPrices(
+    minCreditManager?.chainId ?? strategy.chainId,
+    minCreditManager?.pool || EMPTY_ADDRESS
+  );
+  const underlyingPrice = prices?.[underlyingToken] || 0n;
+  const underlyingDecimals = source.getToken(strategy.chainId, underlyingToken)?.decimals || 18;
+  const availableToBorrowMoney = PriceUtils.calcTotalPrice(
+    underlyingPrice,
+    availableToBorrow,
+    underlyingDecimals
+  );
+  const r = BigInt(effectiveBaseRate) * getFactorFromLeverage(maxLeverage) / maxLeverage;
+  const qr = effectiveQuotaRate;
+  const totalBorrowRate = Number(r + qr);
+  const baseQuotaRateWithFee = getSingleQuotaBorrowRate({
+    quotaRates: minCreditManager?.quotas || {},
+    feeInterest: minCreditManager?.feeInterest || 0,
+    quotas: {
+      [targetTokenAddress]: {
+        token: targetTokenAddress,
+        balance: 1n
+      }
+    }
+  });
+  const points = getStrategyPoints({
+    strategy: {
+      chainId: strategy.chainId,
+      tokenOutAddress: targetTokenAddress
+    },
+    info: {
+      maxLeverage,
+      minCreditManager
+    },
+    strategyCreditManagers: creditManagers ?? {},
+    apyListByNetwork
+  });
+  return {
+    maxLeverage,
+    maxAPY: totalMaxApy,
+    bonusAPY,
+    totalBorrowRate,
+    baseQuotaRateWithFee,
+    availableToBorrowMoney,
+    minCreditManager,
+    points
+  };
+}
+export {
+  getStrategyInfoCore
+};

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

@@ -0,0 +1,50 @@
+import { getStrategyInfoCore } from "./get-strategy-info-core.js";
+function getByAddress(record, address) {
+  return record?.[address] ?? record?.[address.toLowerCase()];
+}
+function getStrategyInfo({
+  strategy,
+  creditManagers,
+  sdkStateByChain,
+  apyListByNetwork,
+  quotaReserve,
+  slippage,
+  allPricesByChain
+}) {
+  return getStrategyInfoCore({
+    strategy,
+    creditManagers: creditManagers?.[strategy.chainId]?.[strategy.id],
+    source: {
+      hasToken(chainId, token) {
+        return !!getByAddress(
+          sdkStateByChain?.[chainId]?.tokens?.tokenDataList,
+          token
+        );
+      },
+      getToken(chainId, token) {
+        return getByAddress(
+          sdkStateByChain?.[chainId]?.tokens?.tokenDataList,
+          token
+        );
+      },
+      getPool(chainId, pool) {
+        return getByAddress(sdkStateByChain?.[chainId]?.pools, pool);
+      },
+      getCreditManager() {
+        return void 0;
+      },
+      getMarketPrices(chainId, pool) {
+        return getByAddress(allPricesByChain?.[chainId]?.prices, pool) || {};
+      },
+      getLastSyncTimestamp() {
+        return void 0;
+      }
+    },
+    apyListByNetwork,
+    quotaReserve,
+    slippage
+  });
+}
+export {
+  getStrategyInfo
+};

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

@@ -0,0 +1,79 @@
+import {
+  LEVERAGE_DECIMALS,
+  PERCENTAGE_FACTOR,
+  toBigInt
+} from "../../../../sdk/index.js";
+import { BONUS_APY_FROM_POINTS } from "../../apy/bonus-apy-from-points.js";
+import { calculateEffectiveBorrowRate } from "../../apy/calculate-effective-borrow-rate.js";
+import { getComplexAPYList } from "../../apy/get-complex-apy-list.js";
+import { getSingleQuotaBorrowRate } from "../../apy/get-single-quota-borrow-rate.js";
+import { maxAPYFormula } from "../../apy/max-apy-formula.js";
+import {
+  calculateMaxLeverageFactor,
+  getLeverageFromFactor
+} from "../leverage/index.js";
+function getStrategyMaxAPY(targetToken, cm, apyListByNetwork, slippage, quotaReserve, leverageLimit) {
+  if (!cm) return void 0;
+  const apyRecord = getComplexAPYList(
+    apyListByNetwork?.[cm.chainId]?.apyList,
+    apyListByNetwork?.[cm.chainId]?.extraCollateralAPYList,
+    cm.pool
+  );
+  const effectiveBaseRate = calculateEffectiveBorrowRate({
+    underlyingTokenAddress: cm.underlyingToken,
+    baseRateWithFee: cm.baseBorrowRate,
+    apyList: apyRecord
+  });
+  const lt = cm.liquidationThresholds[targetToken] || 0n;
+  const feeInterest = cm.feeInterest;
+  const tokenQuota = cm.quotas[targetToken];
+  const qRate = (tokenQuota?.rate || 0n) * lt / PERCENTAGE_FACTOR;
+  const qRate_reserve = qRate * (PERCENTAGE_FACTOR + toBigInt(quotaReserve)) / PERCENTAGE_FACTOR;
+  const effectiveQuotaRate = getSingleQuotaBorrowRate({
+    quotaRates: {
+      [targetToken]: {
+        ...tokenQuota,
+        isActive: tokenQuota?.isActive ?? true,
+        rate: qRate_reserve
+      }
+    },
+    feeInterest,
+    quotas: {
+      [targetToken]: {
+        token: targetToken,
+        balance: 1n
+      }
+    }
+  });
+  const leverage = getLeverageFromFactor(
+    calculateMaxLeverageFactor({
+      targetToken,
+      creditManagers: [cm],
+      slippage,
+      leverageLimit
+    })
+  );
+  const apy = apyRecord?.[targetToken] || 0;
+  const maxAPY = apyRecord ? maxAPYFormula({
+    apy,
+    leverage,
+    baseRateWithFee: effectiveBaseRate,
+    quotaRateWithFee: Number(effectiveQuotaRate)
+  }) : void 0;
+  const bonusAPY = BONUS_APY_FROM_POINTS[targetToken];
+  const bonusAPYTotal = BigInt(bonusAPY?.value || 0) * leverage / LEVERAGE_DECIMALS;
+  const totalMaxApy = (maxAPY || 0) + Number(bonusAPYTotal);
+  const totalBorrowRate = effectiveBaseRate + Number(effectiveQuotaRate);
+  return {
+    totalMaxApy,
+    bonusAPY,
+    maxAPY: maxAPY || 0,
+    maxLeverage: leverage,
+    effectiveBaseRate,
+    effectiveQuotaRate,
+    totalBorrowRate
+  };
+}
+export {
+  getStrategyMaxAPY
+};

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

@@ -0,0 +1,84 @@
+import { isStrategyCMDisabled } from "../../strategies/strategy-info/is-strategy-cm-disabled.js";
+import { getChainPhantomTokens } from "../tokens/get-chain-phantom-tokens.js";
+import { getNativeTokenAddress } from "../tokens/get-native-token-address.js";
+import { getCMYouCanEarn } from "./get-cm-you-can-earn.js";
+function getStrategyYouCanEarn({
+  strategy,
+  creditManagers,
+  sdkState,
+  apyList,
+  quotaReserve,
+  slippage,
+  allPrices,
+  walletBalances
+}) {
+  const strategyCMs = creditManagers;
+  const baseInfo = {
+    strategy: strategy.name,
+    strategyChainId: strategy.chainId,
+    strategyNetwork: strategy.network,
+    strategyType: strategy.strategyType,
+    strategyTokenOutAddress: strategy.tokenOutAddress
+  };
+  if (!strategyCMs || !walletBalances || !allPrices || !apyList || !sdkState) {
+    return [
+      {
+        status: "error",
+        description: "No strategy cms or wallet balances or all prices or apy list or sdk state",
+        otherInfo: baseInfo,
+        data: void 0
+      }
+    ];
+  }
+  const openableCMsList = Object.values(strategyCMs).filter(
+    (cm) => !isStrategyCMDisabled(cm, cm.quotas[strategy.tokenOutAddress])
+  );
+  if (openableCMsList.length === 0) {
+    return [
+      {
+        status: "error",
+        description: "No openable cms list",
+        otherInfo: baseInfo,
+        data: void 0
+      }
+    ];
+  }
+  const pools = sdkState.pools;
+  const tokensList = sdkState.tokens?.tokenDataList;
+  if (!tokensList || !pools || Object.keys(pools).length === 0) {
+    return [
+      {
+        status: "error",
+        description: "No pools or tokens list",
+        otherInfo: baseInfo,
+        data: void 0
+      }
+    ];
+  }
+  const ap = sdkState.addressProvider;
+  const nativeTokenAddress = getNativeTokenAddress();
+  const delayedPhantoms = getChainPhantomTokens(sdkState.withdrawableAssets);
+  const results = openableCMsList.map(
+    (creditManager) => {
+      const info = getCMYouCanEarn({
+        allPrices,
+        creditManager,
+        tokensList,
+        delayedPhantoms,
+        nativeTokenAddress,
+        wrappedNativeTokenAddress: ap.wrappedNativeToken,
+        walletBalances,
+        strategy,
+        slippage,
+        quotaReserve,
+        apyList,
+        pools
+      });
+      return info;
+    }
+  );
+  return results;
+}
+export {
+  getStrategyYouCanEarn
+};

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

@@ -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/esm/common-utils/utils/strategies/strategy-info/is-strategy-cm-disabled.js

@@ -0,0 +1,9 @@
+function isStrategyCMDisabled(cm, quota) {
+  if (!quota) return true;
+  const realLimit = quota.isActive ? quota.limit : 0n;
+  const quotaLeft = realLimit - quota.totalQuoted;
+  return cm.availableToBorrow < cm.minDebt || quotaLeft < cm.minDebt;
+}
+export {
+  isStrategyCMDisabled
+};

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

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

package/dist/esm/common-utils/utils/strategies/strategy-state/is-strategy-disabled.js

@@ -0,0 +1,14 @@
+import { isStrategyCMDisabled } from "../strategy-info/is-strategy-cm-disabled.js";
+const lc = (address) => address.toLowerCase();
+function isStrategyDisabled(tokenOutAddress, cms) {
+  if (cms.length === 0) return true;
+  const targetToken = lc(tokenOutAddress);
+  const allCmsUnavailable = cms.every((cm) => {
+    const quota = cm.quotas[targetToken];
+    return isStrategyCMDisabled(cm, quota);
+  });
+  return allCmsUnavailable;
+}
+export {
+  isStrategyDisabled
+};

package/dist/esm/common-utils/utils/strategies/tokens/add-amount-in-target.js

@@ -0,0 +1,17 @@
+import { PriceUtils } from "../../price-math.js";
+function addAmountInTarget(asset, tokensList, prices, toPrice, toDecimals) {
+  const { balance: fromAmount, token: fromToken } = asset;
+  const { decimals: fromDecimals = 18, address: fromAddress } = tokensList[fromToken] || {};
+  const fromPrice = prices[fromAddress] || 0n;
+  const inTarget = PriceUtils.convertByPrice(
+    PriceUtils.calcTotalPrice(fromPrice, fromAmount, fromDecimals),
+    {
+      price: toPrice,
+      decimals: toDecimals
+    }
+  );
+  return { ...asset, amountInTarget: inTarget };
+}
+export {
+  addAmountInTarget
+};

package/dist/esm/common-utils/utils/strategies/tokens/add-amount-in-target.spec.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import {
+  mockPrices,
+  mockToken1,
+  mockTokenData
+} from "../../../test-utils/index.js";
+import { getDefaultAsset } from "../assets/assets.js";
+import { addAmountInTarget } from "./add-amount-in-target.js";
+describe("addAmountInTarget", () => {
+  const fromToken = mockToken1;
+  const toPrice = 4n;
+  const toDecimals = 18;
+  it("converts amount to target token using prices", () => {
+    const asset = {
+      ...getDefaultAsset(fromToken),
+      balance: 10n ** 18n
+    };
+    const result = addAmountInTarget(
+      asset,
+      mockTokenData,
+      mockPrices,
+      toPrice,
+      toDecimals
+    );
+    expect(result.amountInTarget).toBe(75000000000000000000000000n);
+  });
+  it("handles missing price data gracefully", () => {
+    const asset = { ...getDefaultAsset(fromToken), balance: 10n ** 18n };
+    const tokensList = {
+      [fromToken]: mockTokenData[fromToken]
+    };
+    const result = addAmountInTarget(
+      asset,
+      tokensList,
+      {},
+      toPrice,
+      toDecimals
+    );
+    expect(result.amountInTarget).toBe(0n);
+  });
+});

package/dist/esm/common-utils/utils/strategies/tokens/get-chain-phantom-tokens.js

@@ -0,0 +1,11 @@
+function getChainPhantomTokens(config) {
+  const allConfigs = Object.values(config || {}).flat(1);
+  const r = allConfigs.reduce((acc, cfg) => {
+    acc[cfg.withdrawalPhantomToken] = true;
+    return acc;
+  }, {});
+  return r;
+}
+export {
+  getChainPhantomTokens
+};

package/dist/esm/common-utils/utils/strategies/tokens/get-list-with-amount-in-target.js

@@ -0,0 +1,18 @@
+import { addAmountInTarget } from "./add-amount-in-target.js";
+function getListWithAmountInTarget({
+  assets,
+  targetToken,
+  prices,
+  tokensList
+}) {
+  const { decimals: toDecimals = 18 } = tokensList[targetToken] || {};
+  const toPrice = prices[targetToken] || 0n;
+  const withAmount = assets.map((asset) => {
+    const a = addAmountInTarget(asset, tokensList, prices, toPrice, toDecimals);
+    return a;
+  });
+  return withAmount;
+}
+export {
+  getListWithAmountInTarget
+};

package/dist/esm/common-utils/utils/strategies/tokens/get-list-with-amount-in-target.spec.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import {
+  mockPrices,
+  mockToken1,
+  mockToken2,
+  mockTokenData
+} from "../../../test-utils/index.js";
+import { getDefaultAsset } from "../assets/assets.js";
+import { getListWithAmountInTarget } from "./get-list-with-amount-in-target.js";
+describe("getListWithAmountInTarget", () => {
+  const targetToken = mockToken2;
+  it("converts multiple assets to target token using prices", () => {
+    const assets = [
+      { ...getDefaultAsset(mockToken1), balance: 10n ** 18n },
+      { ...getDefaultAsset(mockToken2), balance: 10n ** 18n }
+    ];
+    const result = getListWithAmountInTarget({
+      assets,
+      targetToken,
+      prices: mockPrices,
+      tokensList: mockTokenData
+    });
+    expect(result).toHaveLength(2);
+    expect(result[0].amountInTarget).toBe(1500000000000000000n);
+    expect(result[1].amountInTarget).toBe(1000000000000000000n);
+  });
+  it("returns empty array for empty assets", () => {
+    const result = getListWithAmountInTarget({
+      assets: [],
+      targetToken,
+      prices: mockPrices,
+      tokensList: mockTokenData
+    });
+    expect(result).toEqual([]);
+  });
+});

package/dist/esm/common-utils/utils/strategies/tokens/get-native-token-address.js

@@ -0,0 +1,7 @@
+const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE".toLowerCase();
+function getNativeTokenAddress() {
+  return NATIVE_ADDRESS;
+}
+export {
+  getNativeTokenAddress
+};

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

@@ -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/esm/common-utils/utils/strategies/tokens/is-activated-token.js

@@ -0,0 +1,12 @@
+function isActivatedToken({
+  address,
+  creditManager
+}) {
+  const zeroLt = creditManager.liquidationThresholds[address] === 0n;
+  const quotaNotActive = creditManager.quotas[address]?.isActive === false;
+  const supportedToken = !!creditManager.supportedTokens[address];
+  return supportedToken && !zeroLt && !quotaNotActive;
+}
+export {
+  isActivatedToken
+};

package/dist/esm/common-utils/utils/strategies/tokens/is-apy-with-points-exception.js

@@ -0,0 +1,11 @@
+const RST_ETH_ADDRESS = "0x7a4EffD87C2f3C55CA251080b1343b605f327E3a".toLowerCase();
+const SHOW_APY_FOR_TOKENS_WITH_POINTS = {
+  [RST_ETH_ADDRESS]: RST_ETH_ADDRESS
+};
+function isApyWithPointsException(token) {
+  return !!SHOW_APY_FOR_TOKENS_WITH_POINTS[(token || "").toLowerCase()];
+}
+export {
+  RST_ETH_ADDRESS,
+  isApyWithPointsException
+};

package/dist/esm/common-utils/utils/strategies/tokens/is-collateral-token.js

@@ -0,0 +1,35 @@
+import { isObtainableToken } from "./is-obtainable-token.js";
+import { isValidExtraCollateralToken } from "./is-valid-extra-collateral-token.js";
+function isCollateralToken({
+  address,
+  tokensList,
+  creditManager,
+  zeroDebt = false,
+  delayedPhantoms,
+  extraCollateralConfigs,
+  prices
+}) {
+  if (creditManager && address === creditManager.underlyingToken) return true;
+  if (zeroDebt && creditManager) return false;
+  const token = tokensList[address];
+  const cmCheckPassed = isObtainableToken({
+    address,
+    creditManager,
+    delayedPhantoms
+  });
+  const { isPhantom = false } = token || {};
+  const allowedAsMain = !isPhantom && cmCheckPassed;
+  const allowedAsExtra = isValidExtraCollateralToken({
+    address,
+    extraCollateralConfigs,
+    creditManager,
+    delayedPhantoms,
+    tokensList,
+    zeroDebt,
+    prices
+  });
+  return allowedAsMain || allowedAsExtra;
+}
+export {
+  isCollateralToken
+};