@gearbox-protocol/sdk 14.6.0-next.3 → 14.6.0-next.5

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/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 { CuratorFilter, GearboxSDKFullStateByChain, StrategiesCMListByChain, Strategy } from "../types.js";
-export declare function getStrategyCreditManagersList(strategies: Array<Strategy> | undefined, sdkStateByChain: GearboxSDKFullStateByChain | undefined, curatorFilter: CuratorFilter): StrategiesCMListByChain | 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 { CreditManagerData_Legacy, Strategy } from "../types.js";
-interface GetStrategyCreditManagersProps {
+import type { Strategy, StrategyCreditManagerView } from "../types.js";
+interface GetStrategyCreditManagersProps<CM extends StrategyCreditManagerView> {
     strategy: Pick<Strategy, "tokenOutAddress" | "creditManagers">;
-    allCreditManagers: Record<Address, CreditManagerData_Legacy>;
+    allCreditManagers: Record<Address, CM>;
 }
-export declare function getStrategyCreditManagers({ strategy, allCreditManagers, }: GetStrategyCreditManagersProps): Record<`0x${string}`, CreditManagerData_Legacy>;
+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 { CreditManagerData_Legacy } from "../types.js";
-export declare function isCreditManagerUsable(cm: Pick<CreditManagerData_Legacy, "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, CuratorFilter, GearboxSDKFullState, NotValidatedStrategy } from "../types.js";
-export declare function isStrategyEligible(s: Pick<NotValidatedStrategy, "chainId" | "network" | "hideInProd" | "tokenOutAddress" | "showInMainApp">, allowedChains: AppChains, showHiddenStrategies: boolean, sdkStateByChain: Record<number, Pick<GearboxSDKFullState, "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 { CuratorFilter, StrategiesCMListByChain, Strategy } from "../types.js";
-export declare function getAvailableAndDisabledStrategies(list: Strategy[] | undefined | undefined, listCMs: StrategiesCMListByChain | 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 { StrategiesCMListByChain, Strategy, StrategyRecord } from "../types.js";
-export declare function getAvailableStrategies(list: Strategy[] | undefined | undefined, listCMs: StrategiesCMListByChain | 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;
 };

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

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

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

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

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

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

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

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

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

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

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

@@ -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/types/common-utils/utils/strategies/strategy-state/is-strategy-disabled.d.ts

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

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

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

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

@@ -1,6 +1,6 @@
 import type { Address } from "viem";
-import type { CreditManagerData_Legacy } from "../types.js";
+import type { StrategyCreditManagerView } from "../types.js";
 export declare function isForbiddenToken({ address, creditManager, }: {
     address: Address;
-    creditManager: Pick<CreditManagerData_Legacy, "forbiddenTokens">;
+    creditManager: Pick<StrategyCreditManagerView, "forbiddenTokens">;
 }): boolean;

package/dist/types/common-utils/utils/strategies/types/credit-manager-data-legacy.d.ts

@@ -1,6 +1,7 @@
 import type { Address } from "viem";
 import type { NetworkType } from "../../../../sdk/index.js";
-import type { CreditManagerSlice, QuotaSlice } from "../strategy-info/types.js";
+import type { QuotaSlice } from "../strategy-info/types.js";
+import type { StrategyCreditManagerView } from "./strategy-data-source.js";
 interface AdapterContract {
     address: Address;
     contractType: string;
@@ -8,24 +9,19 @@ interface AdapterContract {
     name: string;
     targetContract: Address;
 }
-export type CreditManagerData_Legacy = CreditManagerSlice & {
+export type CreditManagerDataSlice = StrategyCreditManagerView & {
     readonly network: NetworkType;
     readonly creditFacade: Address;
     readonly creditConfigurator: Address;
-    readonly version: number;
     readonly isPaused: boolean;
     readonly forbiddenTokenMask: bigint;
-    readonly isBorrowingForbidden: boolean;
     readonly maxEnabledTokensLength: number;
     readonly name: string;
-    readonly marketConfigurator: Address;
     readonly feeLiquidation: number;
     readonly liquidationDiscount: number;
     readonly feeLiquidationExpired: number;
     readonly liquidationDiscountExpired: number;
-    readonly supportedTokens: Record<Address, true>;
     readonly usableTokens: Record<Address, true>;
-    readonly forbiddenTokens: Record<Address, true>;
     readonly adapters: Record<Address, AdapterContract>;
     readonly contractsByAdapter: Record<Address, Address>;
     readonly quotas: Record<Address, QuotaSlice>;

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

@@ -3,7 +3,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/types/common-utils/utils/strategies/types/legacy-strategy-data-source.d.ts

@@ -0,0 +1,4 @@
+import type { PricesByChainSlice } from "../strategy-info/types.js";
+import type { GearboxSDKFullStateByChain } from "./sdk-state.js";
+import type { StrategyCreditManagerView, StrategyDataSource } from "./strategy-data-source.js";
+export declare function createLegacyStrategyDataSource<CM extends StrategyCreditManagerView>(sdkStateByChain: GearboxSDKFullStateByChain<CM> | undefined, pricesByChain?: PricesByChainSlice): StrategyDataSource<CM>;

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

@@ -1,13 +1,14 @@
 import type { Address } from "viem";
-import type { TokenSlice } from "../strategy-info/types.js";
-import type { CreditManagerData_Legacy } from "./credit-manager-data-legacy.js";
-export interface GearboxSDKFullState {
+import type { PoolSlice, TokenSlice } from "../strategy-info/types.js";
+import type { StrategyCreditManagerView } from "./strategy-data-source.js";
+export interface GearboxSDKFullState<CM extends StrategyCreditManagerView> {
     lastSyncBlock?: {
         blockTimestamp_js: number;
     };
     tokens?: {
         tokenDataList?: Record<Address, TokenSlice>;
     };
-    creditManagers?: Record<Address, CreditManagerData_Legacy>;
+    creditManagers?: Record<Address, CM>;
+    pools?: Record<Address, PoolSlice>;
 }
-export type GearboxSDKFullStateByChain = Record<number, GearboxSDKFullState | undefined>;
+export type GearboxSDKFullStateByChain<CM extends StrategyCreditManagerView> = Record<number, GearboxSDKFullState<CM> | undefined>;

package/dist/types/common-utils/utils/strategies/types/strategies-cm-list.d.ts

@@ -1,5 +1,5 @@
 import type { Address } from "viem";
 import type { PartialRecord } from "../../../../sdk/index.js";
-import type { CreditManagerData_Legacy } from "./credit-manager-data-legacy.js";
 import type { Strategy } from "./strategy.js";
-export type StrategiesCMListByChain = Record<number, PartialRecord<Strategy["id"], Record<Address, CreditManagerData_Legacy>>>;
+import type { StrategyCreditManagerView } from "./strategy-data-source.js";
+export type StrategiesCMListByChain<CM extends StrategyCreditManagerView> = Record<number, PartialRecord<Strategy["id"], Record<Address, CM>>>;

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

@@ -0,0 +1,19 @@
+import type { Address } from "viem";
+import type { CreditManagerSlice, PoolSlice, TokenSlice } from "../strategy-info/types.js";
+export interface StrategyCreditManagerView extends CreditManagerSlice {
+    readonly version: number;
+    readonly isBorrowingForbidden: boolean;
+    readonly marketConfigurator: Address;
+    readonly supportedTokens: Record<Address, true>;
+    readonly forbiddenTokens: Record<Address, true>;
+}
+export type StrategyPoolView = PoolSlice;
+export type StrategyTokenView = TokenSlice;
+export interface StrategyDataSource<CM extends StrategyCreditManagerView = StrategyCreditManagerView> {
+    hasToken(chainId: number, token: Address): boolean;
+    getToken(chainId: number, token: Address): StrategyTokenView | undefined;
+    getPool(chainId: number, pool: Address): StrategyPoolView | undefined;
+    getCreditManager(chainId: number, creditManager: Address): CM | undefined;
+    getMarketPrices(chainId: number, pool: Address): Record<Address, bigint>;
+    getLastSyncTimestamp(chainId: number): number | undefined;
+}

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

@@ -1,6 +1,6 @@
 import type { Address } from "viem";
-import type { CreditManagerData_Legacy } from "./credit-manager-data-legacy.js";
+import type { StrategyCreditManagerView } from "./strategy-data-source.js";
 export type IsTargetableProps = {
     address: Address;
-    creditManager: Pick<CreditManagerData_Legacy, "forbiddenTokens" | "liquidationThresholds" | "quotas" | "supportedTokens">;
+    creditManager: Pick<StrategyCreditManagerView, "forbiddenTokens" | "liquidationThresholds" | "quotas" | "supportedTokens">;
 };

package/dist/types/plugins/apy/ApyPlugin.d.ts

@@ -1,8 +1,9 @@
 import type { Address } from "viem";
+import type { StrategyCreditManagerView } from "../../common-utils/utils/strategies/types.js";
 import type { IOnchainSDKPlugin } from "../../sdk/index.js";
 import { AddressMap, BasePlugin } from "../../sdk/index.js";
 import type { GetPoolsAPYResult } from "./pool-apy-types.js";
-import type { ApySnapshotState, Pool7DAgoState, Pools7DAgoStateHuman } from "./types.js";
+import type { ApySnapshotState, GetStrategyInfoSnapshotArgs, Pool7DAgoState, Pools7DAgoStateHuman, StrategyInfoSnapshot } from "./types.js";
 export interface ApyPluginState {
     pools7DAgo: Record<Address, Pool7DAgoState>;
     apySnapshot: ApySnapshotState;
@@ -39,6 +40,12 @@ export declare class ApyPlugin extends BasePlugin<ApyPluginState> implements IOn
      * @throws if plugin is not loaded
      */
     getPoolsAPY(): GetPoolsAPYResult;
+    /**
+     * Computes a strategy-info snapshot from the current SDK and APY state.
+     *
+     * @throws if plugin is not loaded
+     */
+    getStrategyInfoSnapshot({ slippage, quotaReserve, curatorFilter, strategyPayloadsList, showHiddenStrategies, }: GetStrategyInfoSnapshotArgs): StrategyInfoSnapshot<StrategyCreditManagerView>;
     syncState(): Promise<void>;
     stateHuman(_?: boolean): Pools7DAgoStateHuman[];
     get state(): ApyPluginState;

package/dist/types/plugins/apy/strategy-data-source.d.ts

@@ -0,0 +1,16 @@
+import type { Address } from "viem";
+import type { StrategyCreditManagerView, StrategyDataSource, StrategyPoolView, StrategyTokenView } from "../../common-utils/utils/strategies/types.js";
+import { type OnchainSDK } from "../../sdk/index.js";
+export declare class OnchainSdkStrategyDataSource implements StrategyDataSource<StrategyCreditManagerView> {
+    private readonly sdk;
+    constructor(sdk: OnchainSDK);
+    hasToken(chainId: number, token: Address): boolean;
+    getToken(chainId: number, token: Address): StrategyTokenView | undefined;
+    getPool(chainId: number, pool: Address): StrategyPoolView | undefined;
+    getCreditManager(chainId: number, creditManager: Address): StrategyCreditManagerView | undefined;
+    getMarketPrices(chainId: number, pool: Address): Record<Address, bigint>;
+    getLastSyncTimestamp(chainId: number): number | undefined;
+    private toCreditManagerView;
+    private findCreditManager;
+    private getWrappedNativeToken;
+}