@gearbox-protocol/sdk 13.5.0 → 13.6.0-apy-plugin.1

package/dist/cjs/plugins/pools-history/ApyPlugin.js

@@ -0,0 +1,328 @@
+"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 ApyPlugin_exports = {};
+__export(ApyPlugin_exports, {
+  ApyPlugin: () => ApyPlugin
+});
+module.exports = __toCommonJS(ApyPlugin_exports);
+var import_marketCompressor = require("../../abi/compressors/marketCompressor.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");
+var import_hex = require("../../sdk/utils/hex.js");
+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");
+const MAP_LABEL = "pools7DAgo";
+const PLUGIN_KEY = "ApyPlugin";
+class ApyPlugin extends import_sdk.BasePlugin {
+  #timerInterval;
+  #apyUrl;
+  #cacheTtlMs;
+  #pools7DAgo;
+  #apySnapshot;
+  /**
+   * Default timer options
+   * @see PluginTimerOptions
+   */
+  #defaultTimerOptions;
+  /**
+   * When `true`, the timer is started eagerly during the `attach` phase
+   * rather than waiting for an explicit `load` call.
+   **/
+  startTimerOnAttach;
+  constructor(loadOnAttach = false, startTimerOnAttach = false, options) {
+    super(loadOnAttach);
+    this.startTimerOnAttach = startTimerOnAttach;
+    this.#apyUrl = options?.apyUrl ?? import_constants.APY_STATE_CACHE_URL;
+    this.#cacheTtlMs = options?.cacheTtlMs ?? import_constants.DEFAULT_APY_INTERVAL_MS;
+    this.#defaultTimerOptions = options?.timer ?? {
+      refreshPools7DAgoOnTick: false,
+      intervalMs: import_constants.DEFAULT_APY_INTERVAL_MS,
+      onChange: () => {
+      }
+    };
+  }
+  async attach() {
+    await super.attach();
+    if (this.startTimerOnAttach) {
+      this.startTimer();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Load — single entry point for all data (on-chain + state-cache)
+  // ---------------------------------------------------------------------------
+  async load(force, loadOptions) {
+    if (!force && this.loaded) {
+      return this.state;
+    }
+    const targetBlock = this.sdk.currentBlock - import_sdk.BLOCKS_PER_WEEK_BY_NETWORK[this.sdk.networkType];
+    const [marketCompressorAddress] = this.sdk.addressProvider.mustGetLatest(
+      import_sdk.AP_MARKET_COMPRESSOR,
+      import_sdk.VERSION_RANGE_310
+    );
+    this.#logger?.debug(
+      `loading pools 7d ago with market compressor ${marketCompressorAddress}`
+    );
+    const markets = this.sdk.marketRegister.markets;
+    const shouldLoadPools7DAgo = !this.#pools7DAgo || !!loadOptions?.loadPools7DAgo;
+    const [multicallResp, apySnapshot] = await Promise.all([
+      shouldLoadPools7DAgo ? this.client.multicall({
+        allowFailure: true,
+        contracts: markets.map(
+          (m) => ({
+            address: marketCompressorAddress,
+            abi: import_marketCompressor.marketCompressorAbi,
+            functionName: "getPoolState",
+            args: [m.pool.pool.address]
+          })
+        ),
+        blockNumber: targetBlock > 0n ? targetBlock : void 0,
+        batchSize: 0
+      }) : null,
+      this.#fetchApy()
+    ]);
+    if (multicallResp !== null) {
+      this.#pools7DAgo = new import_sdk.AddressMap(void 0, MAP_LABEL);
+      multicallResp.forEach((r, index) => {
+        const m = markets[index];
+        const cfg = m.configurator.address;
+        const pool = m.pool.pool.address;
+        if (r.status === "success") {
+          this.#pools7DAgo?.upsert(m.pool.pool.address, {
+            dieselRate: r.result.dieselRate,
+            pool
+          });
+        } else {
+          this.#logger?.error(
+            `failed to load pools 7d ago for market configurator ${this.labelAddress(cfg)} and pool ${this.labelAddress(pool)}: ${r.error}`
+          );
+        }
+      });
+    }
+    if (apySnapshot) {
+      this.#apySnapshot = apySnapshot;
+    }
+    return this.state;
+  }
+  get loaded() {
+    return !!this.#pools7DAgo && !!this.#apySnapshot;
+  }
+  // ---------------------------------------------------------------------------
+  // Accessors
+  // ---------------------------------------------------------------------------
+  /**
+   * @throws if plugin is not loaded
+   */
+  get pools7DAgo() {
+    if (!this.#pools7DAgo) {
+      throw new Error("apy plugin not loaded");
+    }
+    return this.#pools7DAgo;
+  }
+  /**
+   * @throws if plugin is not loaded
+   */
+  get apySnapshot() {
+    if (!this.#apySnapshot) {
+      throw new Error("apy plugin not loaded");
+    }
+    return this.#apySnapshot;
+  }
+  // ---------------------------------------------------------------------------
+  // Aggregated APY / points
+  // ---------------------------------------------------------------------------
+  /**
+   * Computes per-pool APY (current + 7d-ago) and points for all markets.
+   *
+   * @throws if plugin is not loaded
+   */
+  getPoolsAPY() {
+    if (!this.loaded) {
+      throw new Error("apy plugin not loaded");
+    }
+    const markets = this.sdk.marketRegister.markets;
+    const { apy } = this.apySnapshot;
+    const totalTokenBalances = {};
+    const poolPointsBase = apy.poolRewardsList && Object.keys(apy.poolRewardsList).length > 0 ? import_extra_apy.PoolPointsAPI.getPointsByPool({
+      poolRewards: apy.poolRewardsList,
+      totalTokenBalances,
+      pools: markets,
+      tokensList: this.sdk.tokensMeta
+    }) : {};
+    const data = {};
+    const data7DAgo = {};
+    const points = {};
+    for (const market of markets) {
+      const pool = market.pool.pool;
+      const poolAddr = pool.address.toLowerCase();
+      const depositAPY = (0, import_formatter.rayToNumber)(pool.supplyRate) * Number(import_sdk.PERCENTAGE_DECIMALS);
+      const underlyingAPY = apy.apyList?.[pool.underlying] ?? 0;
+      const lookupAddresses = this.#getExtraAPYLookupAddresses(poolAddr);
+      const extraAPY = (0, import_pool_apy_utils.getPoolExtraAPY)(lookupAddresses, apy.poolExtraAPYList);
+      const currentExternalList = apy.poolExternalAPYList?.[poolAddr];
+      const poolAPY = (0, import_pool_apy_utils.calculatePoolFullAPY)({
+        depositAPY,
+        underlyingAPY,
+        extraAPY,
+        currentExternalList
+      });
+      data[poolAddr] = poolAPY;
+      const pool7DAgo = this.#pools7DAgo?.get(poolAddr);
+      const supplyAPY7DAgo = pool7DAgo ? (0, import_pool_apy_utils.calculateSupplyApy7d)(
+        pool.dieselRate,
+        pool.supplyRate,
+        pool7DAgo.dieselRate
+      ) : void 0;
+      data7DAgo[poolAddr] = (0, import_pool_apy_utils.calculatePoolFullAPY7DAgo)({
+        supplyAPY7DAgo,
+        depositAPY,
+        poolAPY
+      });
+      const poolTokenMeta = this.sdk.tokensMeta.get(pool.underlying);
+      points[poolAddr] = (0, import_pool_apy_utils.calculatePoolPoints)({
+        poolTokenSymbol: poolTokenMeta?.symbol,
+        points: poolPointsBase[poolAddr],
+        tokensList: this.sdk.tokensMeta
+      });
+    }
+    return { data, data7DAgo, points };
+  }
+  // ---------------------------------------------------------------------------
+  // Periodic full refresh
+  // ---------------------------------------------------------------------------
+  /**
+   * Starts a periodic timer that performs a full plugin state refresh.
+   * Only one timer can be active; calling again is a no-op.
+   * @returns Cleanup function that stops the timer.
+   */
+  startTimer(opts) {
+    if (this.#timerInterval) {
+      this.#logger?.debug("plugin timer already running");
+      return () => this.stopTimer();
+    }
+    const intervalMs = opts?.intervalMs ?? this.#defaultTimerOptions.intervalMs;
+    this.#logger?.debug(`starting plugin timer (interval: ${intervalMs}ms)`);
+    this.#timerInterval = setInterval(async () => {
+      try {
+        const prevTimestamp = this.#apySnapshot?.timestamp;
+        await this.load(true, {
+          loadPools7DAgo: opts?.refreshPools7DAgoOnTick ?? this.#defaultTimerOptions.refreshPools7DAgoOnTick
+        });
+        if (this.#apySnapshot?.timestamp !== prevTimestamp) {
+          opts?.onChange?.() ?? this.#defaultTimerOptions.onChange?.();
+          await this.sdk.triggerPluginUpdate(PLUGIN_KEY);
+        }
+      } catch (e) {
+        this.#logger?.error(e, "periodic refresh failed");
+      }
+    }, intervalMs);
+    return () => this.stopTimer();
+  }
+  stopTimer() {
+    if (this.#timerInterval) {
+      clearInterval(this.#timerInterval);
+      this.#timerInterval = void 0;
+      this.#logger?.debug("plugin timer stopped");
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Plugin lifecycle
+  // ---------------------------------------------------------------------------
+  async syncState() {
+    await this.load(true);
+  }
+  stateHuman(_) {
+    return this.pools7DAgo.values().flatMap((p) => ({
+      address: p.pool,
+      version: this.version,
+      dieselRate: p.dieselRate
+    }));
+  }
+  get state() {
+    return {
+      pools7DAgo: this.pools7DAgo.asRecord(),
+      apySnapshot: this.apySnapshot
+    };
+  }
+  hydrate(state) {
+    this.#pools7DAgo = new import_sdk.AddressMap(
+      Object.entries(state.pools7DAgo),
+      MAP_LABEL
+    );
+    this.#apySnapshot = state.apySnapshot;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  async #fetchApy() {
+    try {
+      const cache = import_apy_cache.ApyOutputCache.get(
+        this.#apyUrl,
+        this.#cacheTtlMs,
+        this.#logger
+      );
+      const output = await cache.fetch();
+      if (!output) return void 0;
+      const chainData = output.chains[this.sdk.chainId];
+      if (!chainData) {
+        this.#logger?.debug(
+          `apy state-cache: no data for chainId ${this.sdk.chainId}`
+        );
+        return void 0;
+      }
+      const apy = (0, import_apy_parser.parseNetworkApy)(chainData.tokens, chainData.pools);
+      if (!apy) return void 0;
+      return {
+        apy,
+        gearStats: (0, import_apy_parser.parseGearStats)(output),
+        timestamp: output.timestamp
+      };
+    } catch (e) {
+      this.#logger?.error(e, "failed to fetch apy state-cache");
+      return void 0;
+    }
+  }
+  /**
+   * Collects addresses to look up in poolExtraAPYList for a given pool.
+   * Includes pool address (= diesel token) + any staked diesel token
+   * outputs discovered from zappers.
+   */
+  #getExtraAPYLookupAddresses(poolAddr) {
+    const addresses = [poolAddr];
+    try {
+      const zappers = this.sdk.marketRegister.poolZappers(poolAddr);
+      for (const z of zappers) {
+        if (!(0, import_hex.hexEq)(z.tokenOut.addr, poolAddr)) {
+          addresses.push(z.tokenOut.addr);
+        }
+      }
+    } catch {
+    }
+    return addresses;
+  }
+  get #logger() {
+    return this.logger;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApyPlugin
+});

package/dist/cjs/plugins/pools-history/apy-cache.js

@@ -0,0 +1,120 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var apy_cache_exports = {};
+__export(apy_cache_exports, {
+  ApyOutputCache: () => ApyOutputCache
+});
+module.exports = __toCommonJS(apy_cache_exports);
+var import_axios = __toESM(require("axios"));
+class ApyOutputCache {
+  static #instances = /* @__PURE__ */ new Map();
+  #url;
+  #ttlMs;
+  #cache;
+  #pending;
+  #logger;
+  constructor(url, ttlMs, logger) {
+    this.#url = url;
+    this.#ttlMs = ttlMs;
+    this.#logger = logger;
+  }
+  /**
+   * Returns a shared cache instance for the given URL.
+   * The same instance is reused across all callers with identical URL.
+   */
+  static get(url, ttlMs, logger) {
+    let instance = ApyOutputCache.#instances.get(url);
+    if (!instance) {
+      instance = new ApyOutputCache(url, ttlMs, logger);
+      ApyOutputCache.#instances.set(url, instance);
+    }
+    if (logger) {
+      instance.#logger = logger;
+    }
+    return instance;
+  }
+  /**
+   * Returns cached Output if fresh, otherwise fetches from the network.
+   * Concurrent calls are de-duplicated.
+   */
+  async fetch() {
+    if (this.#cache && Date.now() - this.#cache.fetchedAt < this.#ttlMs) {
+      this.#logger?.debug("apy cache: TTL still valid, returning cached data");
+      return this.#cache.data;
+    }
+    if (this.#pending) {
+      this.#logger?.debug("apy cache: request in flight, waiting");
+      return this.#pending;
+    }
+    this.#pending = this.#doFetch();
+    try {
+      return await this.#pending;
+    } finally {
+      this.#pending = void 0;
+    }
+  }
+  async #doFetch() {
+    try {
+      const headers = {};
+      if (this.#cache?.etag) {
+        headers["If-None-Match"] = this.#cache.etag;
+      }
+      const response = await import_axios.default.get(this.#url, {
+        headers,
+        validateStatus: (status) => status === 200 || status === 304
+      });
+      if (response.status === 304 && this.#cache) {
+        this.#cache.fetchedAt = Date.now();
+        this.#logger?.debug("apy cache: 304 Not Modified, extended TTL");
+        return this.#cache.data;
+      }
+      const etag = response.headers["etag"];
+      this.#cache = {
+        data: response.data,
+        etag,
+        fetchedAt: Date.now()
+      };
+      this.#logger?.debug(
+        `apy cache: fetched fresh data (timestamp: ${response.data.timestamp})`
+      );
+      return response.data;
+    } catch (e) {
+      this.#logger?.error(e, "apy cache: fetch failed");
+      return this.#cache?.data;
+    }
+  }
+  /** Evicts all cached entries. Mainly useful for tests. */
+  static clearAll() {
+    ApyOutputCache.#instances.clear();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApyOutputCache
+});

package/dist/cjs/plugins/pools-history/apy-parser.js

@@ -0,0 +1,169 @@
+"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 apy_parser_exports = {};
+__export(apy_parser_exports, {
+  numberToAPY: () => numberToAPY,
+  parseGearStats: () => parseGearStats,
+  parseNetworkApy: () => parseNetworkApy
+});
+module.exports = __toCommonJS(apy_parser_exports);
+var import_sdk = require("../../sdk/index.js");
+function numberToAPY(baseApy) {
+  return Math.round(baseApy * Number(import_sdk.PERCENTAGE_FACTOR));
+}
+function parseGearStats(output) {
+  const d = output.gearApy?.status === "ok" ? output.gearApy.data : void 0;
+  if (!d) return null;
+  return {
+    base: numberToAPY(d.base ?? 0),
+    crv: numberToAPY(d.crv ?? 0),
+    gear: numberToAPY(d.gear ?? 0),
+    gearPrice: d.gearPrice ?? 0
+  };
+}
+function parseNetworkApy(apyResp, poolResp) {
+  const baseAPYList = {};
+  const extraCollateralAPYList = {};
+  const basePointsList = {};
+  const extraCollateralPointsList = {};
+  const tokenExtraRewardsList = {};
+  const apyData = apyResp?.status === "ok" ? apyResp.data : void 0;
+  for (const d of apyData ?? []) {
+    const tokenAddress = d.address.toLowerCase();
+    const tokenSymbol = d.symbol;
+    const apy = d.rewards.apy?.[0];
+    if (apy) {
+      baseAPYList[tokenAddress] = numberToAPY(apy.value ?? 0);
+    }
+    const points = d.rewards.points?.[0];
+    if (points) {
+      basePointsList[tokenAddress] = {
+        address: tokenAddress,
+        symbol: tokenSymbol,
+        rewards: points.rewards.map((p) => ({
+          ...p,
+          multiplier: p.multiplier === "soon" ? p.multiplier : BigInt(p.multiplier || 0)
+        })),
+        debtRewards: points.debtRewards?.map((p) => ({
+          ...p,
+          cm: (p.cm || "").toLowerCase(),
+          multiplier: p.multiplier === "soon" ? p.multiplier : BigInt(p.multiplier || 0)
+        }))
+      };
+    }
+    const extraRewards = d.rewards.extraRewards;
+    if (extraRewards && extraRewards.length > 0) {
+      tokenExtraRewardsList[tokenAddress] = extraRewards.map((r) => ({
+        address: tokenAddress,
+        symbol: r.rewardSymbol,
+        rewardToken: r.rewardToken.toLowerCase(),
+        rewardSymbol: r.rewardSymbol,
+        token: r.rewardToken.toLowerCase(),
+        finished: BigInt(r.finished || 0),
+        duration: BigInt(r.duration || 0),
+        reward: BigInt(r.reward || 0),
+        balance: BigInt(r.balance || 0)
+      }));
+    }
+    const ecApy = d.rewards.extraCollateralAPY;
+    if (ecApy && ecApy.length > 0) {
+      for (const ea of ecApy) {
+        const pool = ea.pool.toLowerCase();
+        if (!extraCollateralAPYList[pool]) extraCollateralAPYList[pool] = {};
+        extraCollateralAPYList[pool][tokenAddress] = {
+          ...ea,
+          address: tokenAddress,
+          symbol: tokenSymbol,
+          pool,
+          value: numberToAPY(ea.value ?? 0)
+        };
+      }
+    }
+    const ecPoints = d.rewards.extraCollateralPoints;
+    if (ecPoints && ecPoints.length > 0) {
+      for (const ea of ecPoints) {
+        const pool = ea.pool.toLowerCase();
+        if (!extraCollateralPointsList[pool])
+          extraCollateralPointsList[pool] = {};
+        extraCollateralPointsList[pool][tokenAddress] = {
+          address: tokenAddress,
+          symbol: tokenSymbol,
+          rewards: ea.rewards.map((p) => ({
+            ...p,
+            multiplier: p.multiplier === "soon" ? p.multiplier : BigInt(p.multiplier || 0)
+          })),
+          debtRewards: ea.debtRewards?.map((p) => ({
+            ...p,
+            cm: (p.cm || "").toLowerCase(),
+            multiplier: p.multiplier === "soon" ? p.multiplier : BigInt(p.multiplier || 0)
+          }))
+        };
+      }
+    }
+  }
+  const poolRewardsList = {};
+  const poolExternalAPYList = {};
+  const poolExtraAPYList = {};
+  const poolData = poolResp?.status === "ok" ? poolResp.data : void 0;
+  for (const r of poolData ?? []) {
+    const pool = (r.pool || "").toLowerCase();
+    const points = r.rewards.points;
+    if (points && points.length > 0) {
+      poolRewardsList[pool] = points.map((p) => ({
+        ...p,
+        token: p.token.toLowerCase(),
+        pool,
+        amount: BigInt(p.amount || 0)
+      }));
+    }
+    const externalAPY = r.rewards.externalAPY;
+    if (externalAPY && externalAPY.length > 0) {
+      poolExternalAPYList[pool] = externalAPY.map((ex) => ({ ...ex, pool }));
+    }
+    const extraAPY = r.rewards.extraAPY;
+    if (extraAPY && extraAPY.length > 0) {
+      poolExtraAPYList[extraAPY[0].token.toLowerCase()] = extraAPY.map((ex) => ({
+        ...ex,
+        token: ex.token.toLowerCase(),
+        rewardToken: ex.rewardToken.toLowerCase()
+      }));
+    }
+  }
+  const allResponses = [apyResp, poolResp];
+  const allErrors = allResponses.filter((r) => r?.status === "error");
+  if (allResponses.length > 0 && allErrors.length === allResponses.length) {
+    return void 0;
+  }
+  return {
+    apyList: Object.keys(baseAPYList).length > 0 ? baseAPYList : void 0,
+    extraCollateralAPYList: Object.keys(extraCollateralAPYList).length > 0 ? extraCollateralAPYList : void 0,
+    pointsList: Object.keys(basePointsList).length > 0 ? basePointsList : void 0,
+    extraCollateralPointsList: Object.keys(extraCollateralPointsList).length > 0 ? extraCollateralPointsList : void 0,
+    poolRewardsList: Object.keys(poolRewardsList).length > 0 ? poolRewardsList : void 0,
+    tokenExtraRewardsList: Object.keys(tokenExtraRewardsList).length > 0 ? tokenExtraRewardsList : void 0,
+    poolExternalAPYList: Object.keys(poolExternalAPYList).length > 0 ? poolExternalAPYList : void 0,
+    poolExtraAPYList: Object.keys(poolExtraAPYList).length > 0 ? poolExtraAPYList : void 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  numberToAPY,
+  parseGearStats,
+  parseNetworkApy
+});

package/dist/cjs/plugins/pools-history/constants.js

@@ -0,0 +1,31 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  APY_STATE_CACHE_URL: () => APY_STATE_CACHE_URL,
+  DEFAULT_APY_INTERVAL_MS: () => DEFAULT_APY_INTERVAL_MS
+});
+module.exports = __toCommonJS(constants_exports);
+const APY_STATE_CACHE_URL = "https://state-cache.gearbox.foundation/apy-server/latest.json";
+const DEFAULT_APY_INTERVAL_MS = 10 * 60 * 1e3;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APY_STATE_CACHE_URL,
+  DEFAULT_APY_INTERVAL_MS
+});

package/dist/cjs/plugins/pools-history/index.js

@@ -15,10 +15,20 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var pools_history_exports = {};
 module.exports = __toCommonJS(pools_history_exports);
-__reExport(pools_history_exports, require("./Pools7DAgoPlugin.js"), module.exports);
+__reExport(pools_history_exports, require("./ApyPlugin.js"), module.exports);
+__reExport(pools_history_exports, require("./apy-cache.js"), module.exports);
+__reExport(pools_history_exports, require("./apy-parser.js"), module.exports);
+__reExport(pools_history_exports, require("./constants.js"), module.exports);
+__reExport(pools_history_exports, require("./pool-apy-types.js"), module.exports);
+__reExport(pools_history_exports, require("./pool-apy-utils.js"), module.exports);
 __reExport(pools_history_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./Pools7DAgoPlugin.js"),
+  ...require("./ApyPlugin.js"),
+  ...require("./apy-cache.js"),
+  ...require("./apy-parser.js"),
+  ...require("./constants.js"),
+  ...require("./pool-apy-types.js"),
+  ...require("./pool-apy-utils.js"),
   ...require("./types.js")
 });

package/dist/cjs/plugins/pools-history/pool-apy-types.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 pool_apy_types_exports = {};
+module.exports = __toCommonJS(pool_apy_types_exports);