@gearbox-protocol/sdk 13.5.3 → 13.6.0-apy-plugin.2

package/dist/cjs/plugins/pools-history/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/cjs/sdk/utils/viem/simulateWithPriceUpdates.js

@@ -24,8 +24,6 @@ __export(simulateWithPriceUpdates_exports, {
 });
 module.exports = __toCommonJS(simulateWithPriceUpdates_exports);
 var import_viem = require("viem");
-var import_actions = require("viem/actions");
-var import_utils = require("viem/utils");
 var import_errors = require("../../../abi/errors.js");
 var import_iUpdatablePriceFeed = require("../../../abi/iUpdatablePriceFeed.js");
 var import_cast = require("./cast.js");
@@ -55,41 +53,6 @@ async function simulateWithPriceUpdates(client, parameters) {
       "client chain not configured. multicallAddress is required."
     );
   }
-  if (priceUpdates.length === 0 && restContracts.length === 1) {
-    const contract = restContracts[0];
-    const { abi, address, args, functionName } = contract;
-    const callData = (0, import_viem.encodeFunctionData)({ abi, args, functionName });
-    const request2 = {
-      batch: false,
-      data: callData,
-      to: address,
-      blockNumber: rest.blockNumber,
-      blockTag: rest.blockTag,
-      gas: rest.gas,
-      account: rest.account ? (0, import_utils.parseAccount)(rest.account) : client.account,
-      value: rest.value
-    };
-    try {
-      const { data } = await (0, import_utils.getAction)(client, import_actions.call, "call")(request2);
-      const result = (0, import_viem.decodeFunctionResult)({
-        abi,
-        args,
-        data: data || "0x",
-        functionName
-      });
-      return [
-        result
-      ];
-    } catch (e) {
-      throw getSimulateWithPriceUpdatesError(
-        e,
-        priceUpdates,
-        restContracts,
-        void 0,
-        request2
-      );
-    }
-  }
   let request;
   try {
     const contracts = [
@@ -210,8 +173,8 @@ function getSimulateWithPriceUpdatesError(cause, priceUpdates, calls, results, r
     return [extractCallError(result), p.pretty, tsValid].filter(Boolean).join(" ");
   });
   const prettyCalls = callsResults.map((c, i) => {
-    const call2 = calls[i];
-    return [extractCallError(c), `${call2.address}.${call2.functionName}`].filter(Boolean).join(" ");
+    const call = calls[i];
+    return [extractCallError(c), `${call.address}.${call.functionName}`].filter(Boolean).join(" ");
   });
   if (results[0]?.status === "failure") {
     prettyCalls.unshift(

package/dist/esm/plugins/adapters/abi/actionAbi.js

@@ -48,7 +48,7 @@ const adapterActionSignatures = {
     310: "function setPairStatusBatch((address,address,address,uint8)[])",
     311: "function setPairStatusBatch((address,address,address,uint8,uint8)[])"
   },
-  [AdapterType.TRADER_JOE_ROUTER]: {
+  [AdapterType.TRADERJOE_ROUTER]: {
     310: "function setPoolStatusBatch((address,address,uint256,uint8,bool)[])"
   },
   [AdapterType.UNISWAP_V2_ROUTER]: {

package/dist/esm/plugins/adapters/abi/conctructorAbi.js

@@ -63,7 +63,7 @@ const adapterConstructorAbi = {
   [AdapterType.DAI_USDS_EXCHANGE]: {
     310: BASIC_ADAPTER_ABI
   },
-  [AdapterType.TRADER_JOE_ROUTER]: {
+  [AdapterType.TRADERJOE_ROUTER]: {
     310: BASIC_ADAPTER_ABI
   },
   [AdapterType.UNISWAP_V2_ROUTER]: {

package/dist/esm/plugins/adapters/createAdapter.js

@@ -109,7 +109,7 @@ function createAdapter(options, data, strict) {
       return new PendleRouterAdapterContract(options, data);
     case "ADAPTER::STAKING_REWARDS":
       return new StakingRewardsAdapterContract(options, data);
-    case "ADAPTER::TRADER_JOE_ROUTER":
+    case "ADAPTER::TRADERJOE_ROUTER":
       return new TraderJoeRouterAdapterContract(options, data);
     case "ADAPTER::UNISWAP_V2_ROUTER":
       return new UniswapV2AdapterContract(options, data);

package/dist/esm/plugins/adapters/types.js

@@ -36,7 +36,7 @@ var AdapterType = /* @__PURE__ */ ((AdapterType2) => {
   AdapterType2["MIDAS_REDEMPTION_VAULT"] = "MIDAS_REDEMPTION_VAULT";
   AdapterType2["PENDLE_ROUTER"] = "PENDLE_ROUTER";
   AdapterType2["STAKING_REWARDS"] = "STAKING_REWARDS";
-  AdapterType2["TRADER_JOE_ROUTER"] = "TRADER_JOE_ROUTER";
+  AdapterType2["TRADERJOE_ROUTER"] = "TRADERJOE_ROUTER";
   AdapterType2["UNISWAP_V2_ROUTER"] = "UNISWAP_V2_ROUTER";
   AdapterType2["UNISWAP_V3_ROUTER"] = "UNISWAP_V3_ROUTER";
   AdapterType2["UNISWAP_V4_GATEWAY"] = "UNISWAP_V4_GATEWAY";

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

@@ -0,0 +1,254 @@
+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 depositAPY = rayToNumber(pool.supplyRate) * Number(PERCENTAGE_DECIMALS);
+      const underlyingAPY = 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, 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/pools-history/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
+};