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

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

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var legacy_strategy_data_source_exports = {};
+__export(legacy_strategy_data_source_exports, {
+  createLegacyStrategyDataSource: () => createLegacyStrategyDataSource
+});
+module.exports = __toCommonJS(legacy_strategy_data_source_exports);
+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;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLegacyStrategyDataSource
+});

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

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var strategy_data_source_exports = {};
+module.exports = __toCommonJS(strategy_data_source_exports);

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

@@ -22,6 +22,7 @@ __export(ApyPlugin_exports, {
 });
 module.exports = __toCommonJS(ApyPlugin_exports);
 var import_marketCompressor = require("../../abi/compressors/marketCompressor.js");
+var import_strategies = require("../../common-utils/utils/strategies/index.js");
 var import_extra_apy = require("../../rewards/rewards/extra-apy.js");
 var import_sdk = require("../../sdk/index.js");
 var import_formatter = require("../../sdk/utils/formatter.js");
@@ -30,6 +31,7 @@ var import_apy_cache = require("./apy-cache.js");
 var import_apy_parser = require("./apy-parser.js");
 var import_constants = require("./constants.js");
 var import_pool_apy_utils = require("./pool-apy-utils.js");
+var import_strategy_data_source = require("./strategy-data-source.js");
 const MAP_LABEL = "pools7DAgo";
 class ApyPlugin extends import_sdk.BasePlugin {
   #apyUrl;
@@ -181,6 +183,69 @@ class ApyPlugin extends import_sdk.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 import_strategy_data_source.OnchainSdkStrategyDataSource(this.sdk);
+    const releasedStrategies = (0, import_strategies.getReleasedStrategiesListCore)({
+      strategyPayloadsList,
+      allowedChains,
+      source,
+      curatorFilter,
+      showHiddenStrategies
+    });
+    const cmsOfStrategiesByChain = (0, import_strategies.getStrategyCreditManagersListCore)({
+      strategies: releasedStrategies,
+      source,
+      curatorFilter
+    });
+    const { available, disabled, availableList, disabledList } = (0, import_strategies.getAvailableAndDisabledStrategies)(
+      releasedStrategies,
+      cmsOfStrategiesByChain,
+      curatorFilter
+    );
+    const apyListByNetwork = {
+      [chainId]: this.apySnapshot.apy
+    };
+    const strategiesInfo = releasedStrategies?.reduce((acc, strategy) => {
+      const info = (0, import_strategies.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/cjs/plugins/apy/strategy-data-source.js

@@ -0,0 +1,176 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var strategy_data_source_exports = {};
+__export(strategy_data_source_exports, {
+  OnchainSdkStrategyDataSource: () => OnchainSdkStrategyDataSource
+});
+module.exports = __toCommonJS(strategy_data_source_exports);
+var import_sdk = require("../../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 || import_sdk.ADDRESS_0X0];
+    if (wrappedNativePrice !== void 0) {
+      marketPrices[lc(import_sdk.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) * import_sdk.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) + import_sdk.PERCENTAGE_FACTOR) * import_sdk.PERCENTAGE_DECIMALS / import_sdk.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) !== import_sdk.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(import_sdk.AP_WETH_TOKEN, 0)?.toLowerCase();
+    } catch {
+      return void 0;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OnchainSdkStrategyDataSource
+});

package/dist/esm/abi/compressors/subcompressors/withdrawal/infinifiWithdrawalSubcompressor.js

@@ -102,7 +102,8 @@ const infinifiWithdrawalSubcompressorAbi = [
             name: "withdrawalLength",
             type: "uint256",
             internalType: "uint256"
-          }
+          },
+          { name: "maxWithdrawals", type: "uint256", internalType: "uint256" }
         ]
       }
     ],

package/dist/esm/abi/compressors/subcompressors/withdrawal/kelpLRTWithdrawalSubcompressor.js

@@ -102,7 +102,8 @@ const kelpLRTWithdrawalSubcompressorAbi = [
             name: "withdrawalLength",
             type: "uint256",
             internalType: "uint256"
-          }
+          },
+          { name: "maxWithdrawals", type: "uint256", internalType: "uint256" }
         ]
       }
     ],

package/dist/esm/abi/compressors/subcompressors/withdrawal/mellowWithdrawalSubcompressor.js

@@ -102,7 +102,8 @@ const mellowWithdrawalSubcompressorAbi = [
             name: "withdrawalLength",
             type: "uint256",
             internalType: "uint256"
-          }
+          },
+          { name: "maxWithdrawals", type: "uint256", internalType: "uint256" }
         ]
       }
     ],

package/dist/esm/abi/compressors/subcompressors/withdrawal/midasWithdrawalSubcompressor.js

@@ -102,7 +102,8 @@ const midasWithdrawalSubcompressorAbi = [
             name: "withdrawalLength",
             type: "uint256",
             internalType: "uint256"
-          }
+          },
+          { name: "maxWithdrawals", type: "uint256", internalType: "uint256" }
         ]
       }
     ],

package/dist/esm/abi/compressors/subcompressors/withdrawal/securitizeRedemptionSubcompressor.js

@@ -102,7 +102,8 @@ const securitizeRedemptionSubcompressorAbi = [
             name: "withdrawalLength",
             type: "uint256",
             internalType: "uint256"
-          }
+          },
+          { name: "maxWithdrawals", type: "uint256", internalType: "uint256" }
         ]
       }
     ],

package/dist/esm/abi/compressors/subcompressors/withdrawal/upshiftWithdrawalSubcompressor.js

@@ -102,7 +102,8 @@ const upshiftWithdrawalSubcompressorAbi = [
             name: "withdrawalLength",
             type: "uint256",
             internalType: "uint256"
-          }
+          },
+          { name: "maxWithdrawals", type: "uint256", internalType: "uint256" }
         ]
       }
     ],

package/dist/esm/abi/compressors/withdrawalCompressor.js

@@ -122,7 +122,8 @@ const withdrawalCompressorAbi = [
             name: "withdrawalLength",
             type: "uint256",
             internalType: "uint256"
-          }
+          },
+          { name: "maxWithdrawals", type: "uint256", internalType: "uint256" }
         ]
       }
     ],

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

@@ -1,23 +1,12 @@
-import { TypedObjectUtils } from "../../../../sdk/utils/mappers.js";
-import { getStrategyCreditManagers } from "./get-strategy-credit-managers.js";
+import { createLegacyStrategyDataSource } from "../types.js";
+import { getStrategyCreditManagersListCore } from "./get-strategy-credit-managers-list-core.js";
 function getStrategyCreditManagersList(strategies, sdkStateByChain, curatorFilter) {
   if (!sdkStateByChain) return sdkStateByChain;
-  if (!strategies) return strategies;
-  const r = strategies.reduce((acc, s) => {
-    const currentSdkState = sdkStateByChain[s.chainId];
-    const { creditManagers, tokens } = currentSdkState || {};
-    const cms = creditManagers && tokens ? getStrategyCreditManagers({
-      strategy: s,
-      allCreditManagers: creditManagers
-    }) : {};
-    const cmsAfterCuratorFilter = curatorFilter ? TypedObjectUtils.entries(cms).filter(
-      ([, cm]) => curatorFilter[cm.marketConfigurator]
-    ) : TypedObjectUtils.entries(cms);
-    if (!acc[s.chainId]) acc[s.chainId] = {};
-    acc[s.chainId][s.id] = Object.fromEntries(cmsAfterCuratorFilter);
-    return acc;
-  }, {});
-  return r;
+  return getStrategyCreditManagersListCore({
+    strategies,
+    source: createLegacyStrategyDataSource(sdkStateByChain),
+    curatorFilter
+  });
 }
 export {
   getStrategyCreditManagersList

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

@@ -1,13 +1,11 @@
 import { isUsableToken } from "../tokens/is-usable-token.js";
 import { isCreditManagerUsable } from "./is-credit-manager-usable.js";
-function getStrategyCreditManagers({
-  strategy,
-  allCreditManagers
-}) {
-  const lpAddress = strategy.tokenOutAddress;
+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];
+      const cm = allCreditManagers[cmAddress] ?? allCreditManagers[lc(cmAddress)];
       if (cm && isCreditManagerUsable(cm)) {
         const usable = isUsableToken({
           address: lpAddress,

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

@@ -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/esm/common-utils/utils/strategies/lists/get-released-strategies-list-core.js

@@ -0,0 +1,37 @@
+import { isStrategyReleased } from "../eligibility/is-strategy-released.js";
+function getReleasedStrategiesListCore({
+  strategyPayloadsList,
+  allowedChains,
+  source,
+  curatorFilter,
+  showHiddenStrategies
+}) {
+  if (!allowedChains) return void 0;
+  if (!strategyPayloadsList) return void 0;
+  const eligibleStrategies = strategyPayloadsList.reduce(
+    (acc, s) => {
+      const network = s.chainId !== void 0 ? allowedChains[s.chainId] : void 0;
+      const isNetworkCorrect = !!network && network === s.network;
+      const isHidden = !showHiddenStrategies && s.hideInProd;
+      const showInMainApp = s.showInMainApp ?? true;
+      const showCondition = curatorFilter || showInMainApp;
+      if (isNetworkCorrect && !isHidden && source.hasToken(s.chainId, s.tokenOutAddress) && showCondition) {
+        acc.push({
+          ...s,
+          id: s.tokenOutAddress,
+          network
+        });
+      }
+      return acc;
+    },
+    []
+  );
+  return eligibleStrategies.filter((s) => {
+    const lastSyncTimestamp = source.getLastSyncTimestamp(s.chainId);
+    if (!lastSyncTimestamp) return true;
+    return showHiddenStrategies ? true : isStrategyReleased(s.releaseAt, lastSyncTimestamp);
+  });
+}
+export {
+  getReleasedStrategiesListCore
+};

package/dist/esm/common-utils/utils/strategies/lists/get-released-strategies-list.js

@@ -1,35 +1,13 @@
-import { isStrategyEligible } from "../eligibility/is-strategy-eligible.js";
-import { isStrategyReleased } from "../eligibility/is-strategy-released.js";
+import { createLegacyStrategyDataSource } from "../types.js";
+import { getReleasedStrategiesListCore } from "./get-released-strategies-list-core.js";
 function getReleasedStrategiesList(strategyPayloadsList, allowedChains, sdkStateByChain, curatorFilter, showHiddenStrategies) {
-  if (!allowedChains) return void 0;
-  if (!strategyPayloadsList) return void 0;
-  const eligibleStrategies = strategyPayloadsList.reduce(
-    (acc, s) => {
-      const eligible = isStrategyEligible(
-        s,
-        allowedChains,
-        showHiddenStrategies,
-        sdkStateByChain,
-        curatorFilter
-      );
-      if (eligible.isEligible) {
-        acc.push({
-          ...s,
-          id: s.tokenOutAddress,
-          network: eligible.network
-        });
-      }
-      return acc;
-    },
-    []
-  );
-  if (!sdkStateByChain) return eligibleStrategies;
-  const releasedStrategies = eligibleStrategies.filter((s) => {
-    const lastSyncBlock = sdkStateByChain?.[s.chainId]?.lastSyncBlock;
-    if (!lastSyncBlock) return true;
-    return showHiddenStrategies ? true : isStrategyReleased(s.releaseAt, lastSyncBlock.blockTimestamp_js);
-  }, {});
-  return releasedStrategies;
+  return getReleasedStrategiesListCore({
+    strategyPayloadsList,
+    allowedChains,
+    source: createLegacyStrategyDataSource(sdkStateByChain),
+    curatorFilter,
+    showHiddenStrategies
+  });
 }
 export {
   getReleasedStrategiesList

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

@@ -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";