@gearbox-protocol/sdk 14.6.0-next.4 → 14.6.0

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

@@ -0,0 +1,80 @@
+import { PriceUtils } from "../../price-math.js";
+import { getFactorFromLeverage } from "../leverage/index.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,
+    baseBorrowRate = 0,
+    quotaRateMin = 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(baseBorrowRate) * getFactorFromLeverage(maxLeverage) / maxLeverage;
+  const qr = quotaRateMin;
+  const totalBorrowRate = Number(r + qr);
+  return {
+    maxLeverage,
+    maxAPY: totalMaxApy,
+    bonusAPY,
+    totalBorrowRate,
+    availableToBorrowMoney,
+    minCreditManager
+  };
+}
+export {
+  getStrategyInfoCore
+};

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

@@ -1,10 +1,7 @@
-import { PriceUtils } from "../../price-math.js";
-import { getFactorFromLeverage } from "../leverage/index.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 EMPTY_CHAIN_ID = 0;
+import { getStrategyInfoCore } from "./get-strategy-info-core.js";
+function getByAddress(record, address) {
+  return record?.[address] ?? record?.[address.toLowerCase()];
+}
 function getStrategyInfo({
   strategy,
   creditManagers,
@@ -14,60 +11,39 @@ function getStrategyInfo({
   slippage,
   allPricesByChain
 }) {
-  const strategyCMs = creditManagers?.[strategy.chainId]?.[strategy.id] || {};
-  const strategyCMsList = Object.values(strategyCMs);
-  if (strategyCMsList.length === 0) return void 0;
-  const openableCMsList = strategyCMsList.filter(
-    (cm) => !isStrategyCMDisabled(cm, cm.quotas[strategy.tokenOutAddress])
-  );
-  const currentSdkState = sdkStateByChain?.[strategy.chainId];
-  const pools = currentSdkState?.pools;
-  const tokensList = currentSdkState?.tokens?.tokenDataList;
-  const targetTokenAddress = strategy.tokenOutAddress;
-  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,
-    baseBorrowRate = 0,
-    quotaRateMin = 0n
-  } = getStrategyMaxAPY(
-    targetTokenAddress,
-    minCreditManager,
+  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,
-    slippage,
     quotaReserve,
-    strategy.maxLeverage
-  ) || {};
-  const prices = allPricesByChain?.[minCreditManager?.chainId ?? EMPTY_CHAIN_ID]?.prices?.[minCreditManager?.pool || EMPTY_ADDRESS];
-  const underlyingPrice = prices?.[underlyingToken] || 0n;
-  const underlyingDecimals = tokensList?.[underlyingToken]?.decimals || 18;
-  const availableToBorrowMoney = PriceUtils.calcTotalPrice(
-    underlyingPrice,
-    availableToBorrow,
-    underlyingDecimals
-  );
-  const r = BigInt(baseBorrowRate) * getFactorFromLeverage(maxLeverage) / maxLeverage;
-  const qr = quotaRateMin;
-  const totalBorrowRate = Number(r + qr);
-  return {
-    maxLeverage,
-    maxAPY: totalMaxApy,
-    bonusAPY,
-    totalBorrowRate,
-    availableToBorrowMoney,
-    minCreditManager
-  };
+    slippage
+  });
 }
 export {
   getStrategyInfo

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

@@ -1,5 +1,6 @@
 export * from "./cm-availability-condition.js";
 export * from "./get-strategy-info.js";
+export * from "./get-strategy-info-core.js";
 export * from "./get-strategy-max-apy.js";
 export * from "./is-strategy-cm-disabled.js";
 export * from "./types.js";

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

@@ -1,8 +1,10 @@
 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[tokenOutAddress];
+    const quota = cm.quotas[targetToken];
     return isStrategyCMDisabled(cm, quota);
   });
   return allCmsUnavailable;

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

@@ -2,7 +2,9 @@ export * from "./chains.js";
 export * from "./constants.js";
 export * from "./credit-manager-data-legacy.js";
 export * from "./curator-filter.js";
+export * from "./legacy-strategy-data-source.js";
 export * from "./sdk-state.js";
 export * from "./strategies-cm-list.js";
 export * from "./strategy.js";
+export * from "./strategy-data-source.js";
 export * from "./targetable.js";

package/dist/esm/common-utils/utils/strategies/types/legacy-strategy-data-source.js

@@ -0,0 +1,38 @@
+const lc = (address) => address.toLowerCase();
+function getByAddress(record, address) {
+  return record?.[address] ?? record?.[lc(address)];
+}
+function createLegacyStrategyDataSource(sdkStateByChain, pricesByChain) {
+  return {
+    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(chainId, creditManager) {
+      return getByAddress(
+        sdkStateByChain?.[chainId]?.creditManagers,
+        creditManager
+      );
+    },
+    getMarketPrices(chainId, pool) {
+      return getByAddress(pricesByChain?.[chainId]?.prices, pool) ?? {};
+    },
+    getLastSyncTimestamp(chainId) {
+      return sdkStateByChain?.[chainId]?.lastSyncBlock?.blockTimestamp_js;
+    }
+  };
+}
+export {
+  createLegacyStrategyDataSource
+};

package/dist/esm/plugins/apy/ApyPlugin.js

@@ -1,4 +1,10 @@
 import { marketCompressorAbi } from "../../abi/compressors/marketCompressor.js";
+import {
+  getAvailableAndDisabledStrategies,
+  getReleasedStrategiesListCore,
+  getStrategyCreditManagersListCore,
+  getStrategyInfoCore
+} from "../../common-utils/utils/strategies/index.js";
 import { PoolPointsAPI } from "../../rewards/rewards/extra-apy.js";
 import {
   AddressMap,
@@ -20,6 +26,7 @@ import {
   calculateSupplyApy7d,
   getPoolExtraAPY
 } from "./pool-apy-utils.js";
+import { OnchainSdkStrategyDataSource } from "./strategy-data-source.js";
 const MAP_LABEL = "pools7DAgo";
 class ApyPlugin extends BasePlugin {
   #apyUrl;
@@ -171,6 +178,69 @@ class ApyPlugin extends BasePlugin {
     }
     return { data, data7DAgo, pointsBase: poolPointsBase, points };
   }
+  /**
+   * Computes a strategy-info snapshot from the current SDK and APY state.
+   *
+   * @throws if plugin is not loaded
+   */
+  getStrategyInfoSnapshot({
+    slippage,
+    quotaReserve,
+    curatorFilter,
+    strategyPayloadsList,
+    showHiddenStrategies
+  }) {
+    if (!this.loaded) {
+      throw new Error("apy plugin not loaded");
+    }
+    const chainId = this.sdk.chainId;
+    const network = this.sdk.networkType;
+    const allowedChains = { [chainId]: network };
+    const source = new OnchainSdkStrategyDataSource(this.sdk);
+    const releasedStrategies = getReleasedStrategiesListCore({
+      strategyPayloadsList,
+      allowedChains,
+      source,
+      curatorFilter,
+      showHiddenStrategies
+    });
+    const cmsOfStrategiesByChain = getStrategyCreditManagersListCore({
+      strategies: releasedStrategies,
+      source,
+      curatorFilter
+    });
+    const { available, disabled, availableList, disabledList } = getAvailableAndDisabledStrategies(
+      releasedStrategies,
+      cmsOfStrategiesByChain,
+      curatorFilter
+    );
+    const apyListByNetwork = {
+      [chainId]: this.apySnapshot.apy
+    };
+    const strategiesInfo = releasedStrategies?.reduce((acc, strategy) => {
+      const info = getStrategyInfoCore({
+        strategy,
+        creditManagers: cmsOfStrategiesByChain?.[strategy.chainId]?.[strategy.id],
+        source,
+        apyListByNetwork,
+        quotaReserve,
+        slippage
+      });
+      if (info) {
+        acc[strategy.chainId] ??= {};
+        acc[strategy.chainId][strategy.id] = info;
+      }
+      return acc;
+    }, {}) ?? {};
+    return {
+      availableStrategies: available,
+      disabledStrategies: disabled,
+      availableList,
+      disabledList,
+      cmsOfStrategiesByChain,
+      strategiesInfo
+    };
+  }
   // ---------------------------------------------------------------------------
   // Plugin lifecycle
   // ---------------------------------------------------------------------------

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

@@ -0,0 +1,159 @@
+import {
+  ADDRESS_0X0,
+  AP_WETH_TOKEN,
+  NATIVE_ADDRESS,
+  PERCENTAGE_DECIMALS,
+  PERCENTAGE_FACTOR,
+  RAY
+} from "../../sdk/index.js";
+const lc = (address) => address.toLowerCase();
+class OnchainSdkStrategyDataSource {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  sdk;
+  hasToken(chainId, token) {
+    return !!this.getToken(chainId, token);
+  }
+  getToken(chainId, token) {
+    if (chainId !== this.sdk.chainId) return void 0;
+    const meta = this.sdk.tokensMeta.get(token);
+    if (!meta) return void 0;
+    const address = lc(token);
+    return { address, decimals: meta.decimals };
+  }
+  getPool(chainId, pool) {
+    if (chainId !== this.sdk.chainId) return void 0;
+    const market = this.sdk.marketRegister.markets.find(
+      (m) => lc(m.pool.pool.address) === lc(pool)
+    );
+    if (!market) return void 0;
+    return {
+      address: lc(market.pool.pool.address),
+      totalDebtLimit: market.pool.pool.totalDebtLimit,
+      totalBorrowed: market.pool.pool.totalBorrowed
+    };
+  }
+  getCreditManager(chainId, creditManager) {
+    if (chainId !== this.sdk.chainId) return void 0;
+    try {
+      const found = this.findCreditManager(creditManager);
+      if (!found) return void 0;
+      return this.toCreditManagerView(found.creditSuite, found.market.pool);
+    } catch {
+      return void 0;
+    }
+  }
+  getMarketPrices(chainId, pool) {
+    if (chainId !== this.sdk.chainId) return {};
+    const market = this.sdk.marketRegister.markets.find(
+      (m) => lc(m.pool.pool.address) === lc(pool)
+    );
+    if (!market) return {};
+    const marketPrices = Object.fromEntries(
+      market.priceOracle.mainPrices.entries().map(([token, mainPrice]) => {
+        const tokenLc = lc(token);
+        const reservePrice = market.priceOracle.reservePrices?.get(token);
+        return [tokenLc, mainPrice?.price || reservePrice?.price || 0n];
+      })
+    );
+    const wrappedNativeToken = this.getWrappedNativeToken();
+    const wrappedNativePrice = marketPrices[wrappedNativeToken || ADDRESS_0X0];
+    if (wrappedNativePrice !== void 0) {
+      marketPrices[lc(NATIVE_ADDRESS)] = wrappedNativePrice;
+    }
+    return marketPrices;
+  }
+  getLastSyncTimestamp(chainId) {
+    return chainId === this.sdk.chainId ? Number(this.sdk.timestamp) : void 0;
+  }
+  toCreditManagerView(cs, pool) {
+    const cm = cs.creditManager;
+    const facade = cs.creditFacade;
+    const debtParams = pool.pool.creditManagerDebtParams.get(cm.address);
+    const liquidationThresholds = {};
+    const supportedTokens = {};
+    const forbiddenTokens = {};
+    const quotas = {};
+    for (const [token, q] of pool.pqk.quotas.entries()) {
+      const tokenLc = lc(token);
+      quotas[tokenLc] = {
+        token: tokenLc,
+        rate: BigInt(q.rate) * PERCENTAGE_DECIMALS,
+        quotaIncreaseFee: BigInt(q.quotaIncreaseFee),
+        totalQuoted: q.totalQuoted,
+        limit: q.limit,
+        isActive: q.isActive
+      };
+    }
+    for (const token of cm.collateralTokens) {
+      const tokenLc = lc(token);
+      const lt = cm.liquidationThresholds.get(token);
+      if (lt !== void 0) {
+        liquidationThresholds[tokenLc] = BigInt(lt);
+      }
+      supportedTokens[tokenLc] = true;
+    }
+    const forbiddenMask = facade.forbiddenTokensMask;
+    for (let i = 0; i < cm.collateralTokens.length; i++) {
+      const tokenLc = lc(cm.collateralTokens[i]);
+      if ((forbiddenMask & 1n << BigInt(i)) !== 0n) {
+        forbiddenTokens[tokenLc] = true;
+      }
+    }
+    const baseBorrowRate = debtParams ? Number(
+      pool.pool.baseInterestRate * (BigInt(cm.feeInterest) + PERCENTAGE_FACTOR) * PERCENTAGE_DECIMALS / RAY
+    ) : 0;
+    return {
+      address: lc(cm.address),
+      underlyingToken: lc(cm.underlying),
+      pool: lc(cm.pool),
+      chainId: this.sdk.chainId,
+      baseBorrowRate,
+      feeInterest: cm.feeInterest,
+      availableToBorrow: debtParams?.available ?? 0n,
+      minDebt: facade.minDebt,
+      maxDebt: facade.maxDebt,
+      totalDebt: debtParams?.borrowed ?? 0n,
+      totalDebtLimit: debtParams?.limit ?? 0n,
+      isDegenMode: lc(facade.degenNFT) !== ADDRESS_0X0,
+      degenNFT: lc(facade.degenNFT),
+      liquidationThresholds,
+      quotas,
+      collateralTokens: cm.collateralTokens.map(lc),
+      version: Number(facade.version),
+      isBorrowingForbidden: facade.maxDebtPerBlockMultiplier === 0,
+      marketConfigurator: lc(cs.marketConfigurator),
+      supportedTokens,
+      forbiddenTokens
+    };
+  }
+  findCreditManager(creditManager) {
+    const marketRegister = this.sdk.marketRegister;
+    if (marketRegister.findCreditManager && marketRegister.findByCreditManager) {
+      const creditSuite = marketRegister.findCreditManager(creditManager);
+      const market = marketRegister.findByCreditManager(
+        creditSuite.creditManager.address
+      );
+      return { creditSuite, market };
+    }
+    const cmLc = lc(creditManager);
+    for (const market of marketRegister.markets) {
+      const creditSuite = market.creditManagers.find(
+        (cs) => lc(cs.creditManager.address) === cmLc
+      );
+      if (creditSuite) return { creditSuite, market };
+    }
+    return void 0;
+  }
+  getWrappedNativeToken() {
+    try {
+      return this.sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0)?.toLowerCase();
+    } catch {
+      return void 0;
+    }
+  }
+}
+export {
+  OnchainSdkStrategyDataSource
+};

package/dist/types/abi/compressors/subcompressors/withdrawal/infinifiWithdrawalSubcompressor.d.ts

@@ -135,6 +135,10 @@ export declare const infinifiWithdrawalSubcompressorAbi: readonly [{
             readonly name: "withdrawalLength";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "maxWithdrawals";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
         }];
     }];
     readonly stateMutability: "view";

package/dist/types/abi/compressors/subcompressors/withdrawal/kelpLRTWithdrawalSubcompressor.d.ts

@@ -135,6 +135,10 @@ export declare const kelpLRTWithdrawalSubcompressorAbi: readonly [{
             readonly name: "withdrawalLength";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "maxWithdrawals";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
         }];
     }];
     readonly stateMutability: "view";

package/dist/types/abi/compressors/subcompressors/withdrawal/mellowWithdrawalSubcompressor.d.ts

@@ -135,6 +135,10 @@ export declare const mellowWithdrawalSubcompressorAbi: readonly [{
             readonly name: "withdrawalLength";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "maxWithdrawals";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
         }];
     }];
     readonly stateMutability: "view";

package/dist/types/abi/compressors/subcompressors/withdrawal/midasWithdrawalSubcompressor.d.ts

@@ -135,6 +135,10 @@ export declare const midasWithdrawalSubcompressorAbi: readonly [{
             readonly name: "withdrawalLength";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "maxWithdrawals";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
         }];
     }];
     readonly stateMutability: "view";

package/dist/types/abi/compressors/subcompressors/withdrawal/securitizeRedemptionSubcompressor.d.ts

@@ -135,6 +135,10 @@ export declare const securitizeRedemptionSubcompressorAbi: readonly [{
             readonly name: "withdrawalLength";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "maxWithdrawals";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
         }];
     }];
     readonly stateMutability: "view";

package/dist/types/abi/compressors/subcompressors/withdrawal/upshiftWithdrawalSubcompressor.d.ts

@@ -135,6 +135,10 @@ export declare const upshiftWithdrawalSubcompressorAbi: readonly [{
             readonly name: "withdrawalLength";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "maxWithdrawals";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
         }];
     }];
     readonly stateMutability: "view";

package/dist/types/abi/compressors/withdrawalCompressor.d.ts

@@ -163,6 +163,10 @@ export declare const withdrawalCompressorAbi: readonly [{
             readonly name: "withdrawalLength";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "maxWithdrawals";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
         }];
     }];
     readonly stateMutability: "view";

package/dist/types/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers-list-core.d.ts

@@ -0,0 +1,7 @@
+import type { CuratorFilter, StrategiesCMListByChain, Strategy, StrategyCreditManagerView, StrategyDataSource } from "../types.js";
+export interface GetStrategyCreditManagersListCoreArgs<CM extends StrategyCreditManagerView> {
+    strategies: Array<Strategy> | undefined;
+    source: StrategyDataSource<CM>;
+    curatorFilter: CuratorFilter;
+}
+export declare function getStrategyCreditManagersListCore<CM extends StrategyCreditManagerView>({ strategies, source, curatorFilter, }: GetStrategyCreditManagersListCoreArgs<CM>): StrategiesCMListByChain<CM> | undefined;

package/dist/types/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers-list.d.ts

@@ -1,2 +1,2 @@
-import type { CreditManagerDataSlice, CuratorFilter, GearboxSDKFullStateByChain, StrategiesCMListByChain, Strategy } from "../types.js";
-export declare function getStrategyCreditManagersList<CM extends CreditManagerDataSlice>(strategies: Array<Strategy> | undefined, sdkStateByChain: GearboxSDKFullStateByChain<CM> | undefined, curatorFilter: CuratorFilter): StrategiesCMListByChain<CM> | undefined;
+import type { CuratorFilter, GearboxSDKFullStateByChain, Strategy, StrategyCreditManagerView } from "../types.js";
+export declare function getStrategyCreditManagersList<CM extends StrategyCreditManagerView>(strategies: Array<Strategy> | undefined, sdkStateByChain: GearboxSDKFullStateByChain<CM> | undefined, curatorFilter: CuratorFilter): import("../types.js").StrategiesCMListByChain<CM> | undefined;

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

@@ -1,8 +1,8 @@
 import type { Address } from "viem";
-import type { CreditManagerDataSlice, Strategy } from "../types.js";
-interface GetStrategyCreditManagersProps<CM extends CreditManagerDataSlice> {
+import type { Strategy, StrategyCreditManagerView } from "../types.js";
+interface GetStrategyCreditManagersProps<CM extends StrategyCreditManagerView> {
     strategy: Pick<Strategy, "tokenOutAddress" | "creditManagers">;
     allCreditManagers: Record<Address, CM>;
 }
-export declare function getStrategyCreditManagers<CM extends CreditManagerDataSlice>({ strategy, allCreditManagers, }: GetStrategyCreditManagersProps<CM>): Record<`0x${string}`, CM>;
+export declare function getStrategyCreditManagers<CM extends StrategyCreditManagerView>({ strategy, allCreditManagers }: GetStrategyCreditManagersProps<CM>): Record<`0x${string}`, CM>;
 export {};

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

@@ -1,3 +1,4 @@
 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 "./is-credit-manager-usable.js";

package/dist/types/common-utils/utils/strategies/credit-managers/is-credit-manager-usable.d.ts

@@ -1,2 +1,2 @@
-import type { CreditManagerDataSlice } from "../types.js";
-export declare function isCreditManagerUsable(cm: Pick<CreditManagerDataSlice, "isBorrowingForbidden" | "version">): boolean;
+import type { StrategyCreditManagerView } from "../types.js";
+export declare function isCreditManagerUsable(cm: Pick<StrategyCreditManagerView, "isBorrowingForbidden" | "version">): boolean;

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

@@ -1,5 +1,5 @@
-import type { AppChains, CreditManagerDataSlice, CuratorFilter, GearboxSDKFullState, NotValidatedStrategy } from "../types.js";
-export declare function isStrategyEligible<CM extends CreditManagerDataSlice>(s: Pick<NotValidatedStrategy, "chainId" | "network" | "hideInProd" | "tokenOutAddress" | "showInMainApp">, allowedChains: AppChains, showHiddenStrategies: boolean, sdkStateByChain: Record<number, Pick<GearboxSDKFullState<CM>, "tokens"> | undefined> | undefined, curatorFilter: CuratorFilter): {
+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";
 } | {

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

@@ -1,5 +1,5 @@
-import type { CreditManagerDataSlice, CuratorFilter, StrategiesCMListByChain, Strategy } from "../types.js";
-export declare function getAvailableAndDisabledStrategies<CM extends CreditManagerDataSlice>(list: Strategy[] | undefined | undefined, listCMs: StrategiesCMListByChain<CM> | undefined, curatorFilter: CuratorFilter | undefined): {
+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;

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

@@ -1,5 +1,5 @@
-import type { CreditManagerDataSlice, StrategiesCMListByChain, Strategy, StrategyRecord } from "../types.js";
-export declare function getAvailableStrategies<CM extends CreditManagerDataSlice>(list: Strategy[] | undefined | undefined, listCMs: StrategiesCMListByChain<CM> | undefined): {
+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;
 };