@gearbox-protocol/sdk 14.0.0-next.1 → 14.0.0-next.2

package/dist/cjs/plugins/apy/pool-apy-utils.js

@@ -0,0 +1,141 @@
+"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 pool_apy_utils_exports = {};
+__export(pool_apy_utils_exports, {
+  calculatePoolFullAPY: () => calculatePoolFullAPY,
+  calculatePoolFullAPY7DAgo: () => calculatePoolFullAPY7DAgo,
+  calculatePoolPoints: () => calculatePoolPoints,
+  calculateSupplyApy7d: () => calculateSupplyApy7d,
+  getPoolExtraAPY: () => getPoolExtraAPY
+});
+module.exports = __toCommonJS(pool_apy_utils_exports);
+var import_constants = require("../../sdk/constants/index.js");
+var import_formatter = require("../../sdk/utils/formatter.js");
+const SCALE = 1000000n;
+const WEEKS_PER_YEAR = 54n;
+function getPoolExtraAPY(lookupAddresses, poolExtraAPYList) {
+  if (!poolExtraAPYList) return [];
+  const result = [];
+  for (const addr of lookupAddresses) {
+    const extra = poolExtraAPYList[addr.toLowerCase()];
+    if (extra) {
+      result.push(...extra);
+    }
+  }
+  return result;
+}
+function calculateSupplyApy7d(currentDieselRate, currentSupplyRate, dieselRate7DAgo) {
+  if (dieselRate7DAgo > currentDieselRate) {
+    return (0, import_formatter.rayToNumber)(currentSupplyRate * SCALE) / Number(import_constants.PERCENTAGE_FACTOR);
+  }
+  const apy = (currentDieselRate * import_constants.RAY / dieselRate7DAgo - import_constants.RAY) * WEEKS_PER_YEAR;
+  return (0, import_formatter.rayToNumber)(apy * SCALE) / Number(import_constants.PERCENTAGE_FACTOR);
+}
+function calculatePoolFullAPY({
+  depositAPY,
+  underlyingAPY,
+  extraAPY,
+  currentExternalList
+}) {
+  const baseAPY = [
+    { type: "supplyAPY", apy: depositAPY },
+    ...underlyingAPY > 0 ? [
+      {
+        type: "tokenYield",
+        apy: Number(underlyingAPY) / Number(import_constants.PERCENTAGE_FACTOR)
+      }
+    ] : []
+  ];
+  const filteredExtra = [...extraAPY ?? []].filter((r) => r.apy > 0);
+  const baseAPYTotal = baseAPY.reduce((s, r) => s + (r.apy || 0), 0);
+  const extraAPYTotal = filteredExtra.reduce((s, r) => s + (r.apy || 0), 0);
+  const total = baseAPYTotal + extraAPYTotal;
+  const externalAPY = resolveExternalAPY(currentExternalList, total);
+  return {
+    totalAPY: total,
+    baseAPY,
+    extraAPY: filteredExtra,
+    extraAPYTotal,
+    externalAPY
+  };
+}
+function resolveExternalAPY(list, baseTotal) {
+  const first = list?.[0];
+  if (!first) return void 0;
+  return {
+    ...first,
+    totalValue: baseTotal + first.value
+  };
+}
+function calculatePoolFullAPY7DAgo({
+  supplyAPY7DAgo,
+  depositAPY,
+  poolAPY
+}) {
+  const {
+    baseAPY = [],
+    extraAPYTotal = 0,
+    extraAPY = [],
+    externalAPY
+  } = poolAPY ?? {};
+  const base = [
+    { apy: supplyAPY7DAgo || depositAPY, type: "supplyAPY" },
+    ...baseAPY.filter((r) => r.type !== "supplyAPY")
+  ];
+  const baseTotal = base.reduce((acc, r) => acc + r.apy, 0);
+  const total = baseTotal + extraAPYTotal;
+  return {
+    totalAPY: total,
+    extraAPYTotal,
+    baseAPY: base,
+    extraAPY,
+    externalAPY,
+    loading7DAgo: supplyAPY7DAgo === void 0
+  };
+}
+function calculatePoolPoints({
+  poolTokenSymbol,
+  points,
+  tokensList
+}) {
+  return points?.map(({ info, points: pts }) => {
+    const { decimals = 18 } = tokensList.get(info.token) || {};
+    const amount = (0, import_formatter.formatBN)(pts, decimals);
+    const { name = "Points", duration } = info ?? {};
+    return {
+      reward: info,
+      name,
+      amount,
+      tokenTitle: poolTokenSymbol,
+      fullTip: [
+        `${amount} ${name}`,
+        ...duration ? [duration] : [],
+        ...poolTokenSymbol ? [poolTokenSymbol] : []
+      ].join(" per ")
+    };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculatePoolFullAPY,
+  calculatePoolFullAPY7DAgo,
+  calculatePoolPoints,
+  calculateSupplyApy7d,
+  getPoolExtraAPY
+});

package/dist/cjs/rewards/rewards/extra-apy.js

@@ -82,11 +82,13 @@ class PoolPointsAPI {
     tokensList
   }) {
     const r = pools.reduce((acc, p) => {
-      const pointsInfo = poolRewards[p.address] || [];
+      const poolAddress = p.pool.pool.address.toLowerCase();
+      const pointsInfo = poolRewards[poolAddress] || [];
       const poolPointsList = pointsInfo.reduce(
         (acc2, pointsInfo2) => {
-          const { address: tokenAddress } = tokensList[pointsInfo2.token] || {};
-          const tokenBalance = totalTokenBalances[tokenAddress || ""];
+          const { addr: tokenAddress } = tokensList.get(pointsInfo2.token) || {};
+          const tokenAddressLower = (tokenAddress || "").toLowerCase();
+          const tokenBalance = totalTokenBalances[tokenAddressLower];
           const points = PoolPointsAPI.getPoolTokenPoints(
             tokenBalance,
             p,
@@ -104,22 +106,22 @@ class PoolPointsAPI {
         },
         []
       );
-      acc[p.address] = poolPointsList;
+      acc[poolAddress] = poolPointsList;
       return acc;
     }, {});
     return r;
   }
   static getPoolTokenPoints(tokenBalanceInPool, pool, tokensList, pointsInfo) {
-    if (pool.expectedLiquidity <= 0) return 0n;
+    if (pool.pool.pool.expectedLiquidity <= 0) return 0n;
     if (pointsInfo.estimation === "relative" && !tokenBalanceInPool)
       return null;
-    const { decimals = 18 } = tokensList[pointsInfo.token] || {};
+    const { decimals = 18 } = tokensList.get(pointsInfo.token) || {};
     const targetFactor = 10n ** BigInt(decimals);
     const defaultPoints = pointsInfo.amount * targetFactor / import_sdk.PERCENTAGE_FACTOR;
     if (pointsInfo.estimation === "absolute") return defaultPoints;
-    const { decimals: underlyingDecimals = 18 } = tokensList[pool.underlyingToken] || {};
+    const { decimals: underlyingDecimals = 18 } = tokensList.get(pool.pool.pool.underlying) || {};
     const underlyingFactor = 10n ** BigInt(underlyingDecimals);
-    const points = (tokenBalanceInPool?.balance || 0n) * defaultPoints / (pool.expectedLiquidity * targetFactor / underlyingFactor);
+    const points = (tokenBalanceInPool?.balance || 0n) * defaultPoints / (pool.pool.pool.expectedLiquidity * targetFactor / underlyingFactor);
     return import_common_utils.BigIntMath.min(points, defaultPoints);
   }
 }

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

@@ -0,0 +1,255 @@
+import { marketCompressorAbi } from "../../abi/compressors/marketCompressor.js";
+import { PoolPointsAPI } from "../../rewards/rewards/extra-apy.js";
+import {
+  AddressMap,
+  AP_MARKET_COMPRESSOR,
+  BasePlugin,
+  BLOCKS_PER_WEEK_BY_NETWORK,
+  PERCENTAGE_DECIMALS,
+  VERSION_RANGE_310
+} from "../../sdk/index.js";
+import { rayToNumber } from "../../sdk/utils/formatter.js";
+import { hexEq } from "../../sdk/utils/hex.js";
+import { ApyOutputCache } from "./apy-cache.js";
+import { parseGearStats, parseNetworkApy } from "./apy-parser.js";
+import { APY_STATE_CACHE_URL, DEFAULT_APY_INTERVAL_MS } from "./constants.js";
+import {
+  calculatePoolFullAPY,
+  calculatePoolFullAPY7DAgo,
+  calculatePoolPoints,
+  calculateSupplyApy7d,
+  getPoolExtraAPY
+} from "./pool-apy-utils.js";
+const MAP_LABEL = "pools7DAgo";
+class ApyPlugin extends BasePlugin {
+  #apyUrl;
+  #cacheTtlMs;
+  #pools7DAgo;
+  #apySnapshot;
+  constructor(loadOnAttach = false, options) {
+    super(loadOnAttach);
+    this.#apyUrl = options?.apyUrl ?? APY_STATE_CACHE_URL;
+    this.#cacheTtlMs = options?.cacheTtlMs ?? DEFAULT_APY_INTERVAL_MS;
+  }
+  // ---------------------------------------------------------------------------
+  // 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 - BLOCKS_PER_WEEK_BY_NETWORK[this.sdk.networkType];
+    const [marketCompressorAddress] = this.sdk.addressProvider.mustGetLatest(
+      AP_MARKET_COMPRESSOR,
+      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: 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 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 ? 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 underlyingLc = pool.underlying.toLowerCase();
+      const depositAPY = rayToNumber(pool.supplyRate) * Number(PERCENTAGE_DECIMALS);
+      const underlyingAPY = apy.apyList?.[underlyingLc] ?? apy.apyList?.[pool.underlying] ?? 0;
+      const lookupAddresses = this.#getExtraAPYLookupAddresses(poolAddr);
+      const extraAPY = getPoolExtraAPY(lookupAddresses, apy.poolExtraAPYList);
+      const currentExternalList = apy.poolExternalAPYList?.[poolAddr];
+      const poolAPY = calculatePoolFullAPY({
+        depositAPY,
+        underlyingAPY,
+        extraAPY,
+        currentExternalList
+      });
+      data[poolAddr] = poolAPY;
+      const pool7DAgo = this.#pools7DAgo?.get(poolAddr);
+      const supplyAPY7DAgo = pool7DAgo ? calculateSupplyApy7d(
+        pool.dieselRate,
+        pool.supplyRate,
+        pool7DAgo.dieselRate
+      ) : void 0;
+      data7DAgo[poolAddr] = calculatePoolFullAPY7DAgo({
+        supplyAPY7DAgo,
+        depositAPY,
+        poolAPY
+      });
+      const poolTokenMeta = this.sdk.tokensMeta.get(pool.underlying);
+      points[poolAddr] = calculatePoolPoints({
+        poolTokenSymbol: poolTokenMeta?.symbol,
+        points: poolPointsBase[poolAddr],
+        tokensList: this.sdk.tokensMeta
+      });
+    }
+    return { data, data7DAgo, pointsBase: poolPointsBase, points };
+  }
+  // ---------------------------------------------------------------------------
+  // Plugin lifecycle
+  // ---------------------------------------------------------------------------
+  async syncState() {
+    await this.load();
+  }
+  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 AddressMap(
+      Object.entries(state.pools7DAgo),
+      MAP_LABEL
+    );
+    this.#apySnapshot = state.apySnapshot;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  async #fetchApy() {
+    try {
+      const 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 = parseNetworkApy(chainData.tokens, chainData.pools);
+      if (!apy) return void 0;
+      return {
+        apy,
+        gearStats: 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 (!hexEq(z.tokenOut.addr, poolAddr)) {
+          addresses.push(z.tokenOut.addr);
+        }
+      }
+    } catch {
+    }
+    return addresses;
+  }
+  get #logger() {
+    return this.logger;
+  }
+}
+export {
+  ApyPlugin
+};

package/dist/esm/plugins/apy/apy-cache.js

@@ -0,0 +1,86 @@
+import axios from "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 axios.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();
+  }
+}
+export {
+  ApyOutputCache
+};

package/dist/esm/plugins/apy/apy-parser.js

@@ -0,0 +1,143 @@
+import { PERCENTAGE_FACTOR } from "../../sdk/index.js";
+function numberToAPY(baseApy) {
+  return Math.round(baseApy * Number(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
+  };
+}
+export {
+  numberToAPY,
+  parseGearStats,
+  parseNetworkApy
+};

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

@@ -0,0 +1,6 @@
+const APY_STATE_CACHE_URL = "https://state-cache.gearbox.foundation/apy-server/latest.json";
+const DEFAULT_APY_INTERVAL_MS = 10 * 60 * 1e3;
+export {
+  APY_STATE_CACHE_URL,
+  DEFAULT_APY_INTERVAL_MS
+};

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

@@ -0,0 +1,7 @@
+export * from "./ApyPlugin.js";
+export * from "./apy-cache.js";
+export * from "./apy-parser.js";
+export * from "./constants.js";
+export * from "./pool-apy-types.js";
+export * from "./pool-apy-utils.js";
+export * from "./types.js";