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

package/dist/esm/plugins/pools-history/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/pools-history/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/pools-history/index.js

@@ -1,2 +1,7 @@
-export * from "./Pools7DAgoPlugin.js";
+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";

package/dist/esm/plugins/pools-history/pool-apy-utils.js

@@ -0,0 +1,113 @@
+import { PERCENTAGE_FACTOR, RAY } from "../../sdk/constants/index.js";
+import { formatBN, rayToNumber } from "../../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 rayToNumber(currentSupplyRate * SCALE) / Number(PERCENTAGE_FACTOR);
+  }
+  const apy = (currentDieselRate * RAY / dieselRate7DAgo - RAY) * WEEKS_PER_YEAR;
+  return rayToNumber(apy * SCALE) / Number(PERCENTAGE_FACTOR);
+}
+function calculatePoolFullAPY({
+  depositAPY,
+  underlyingAPY,
+  extraAPY,
+  currentExternalList
+}) {
+  const baseAPY = [
+    { type: "supplyAPY", apy: depositAPY },
+    ...underlyingAPY > 0 ? [
+      {
+        type: "tokenYield",
+        apy: Number(underlyingAPY) / Number(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 = formatBN(pts, decimals);
+    const { name = "Points", duration } = info ?? {};
+    return {
+      reward: info,
+      name,
+      amount,
+      tokenTitle: poolTokenSymbol,
+      fullTip: [
+        `${amount} ${name}`,
+        ...duration ? [duration] : [],
+        ...poolTokenSymbol ? [poolTokenSymbol] : []
+      ].join(" per ")
+    };
+  });
+}
+export {
+  calculatePoolFullAPY,
+  calculatePoolFullAPY7DAgo,
+  calculatePoolPoints,
+  calculateSupplyApy7d,
+  getPoolExtraAPY
+};

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

@@ -52,11 +52,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,
@@ -74,22 +76,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 / 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 BigIntMath.min(points, defaultPoints);
   }
 }

package/dist/esm/sdk/GearboxSDK.js

@@ -101,6 +101,17 @@ class GearboxSDK extends ChainContractsRegister {
    * @see {@link SDKHooks} for available event names.
    **/
   removeHook = this.#hooks.removeHook.bind(this.#hooks);
+  /**
+   * Triggers the `pluginUpdate` hook.
+   *
+   * Intended to be called by plugins when they update their internal state
+   * outside of the normal `syncState`/`rehydrate` cycle (e.g. via an
+   * internal timer).  Frontend listeners registered with
+   * `sdk.addHook("pluginUpdate", …)` will be notified.
+   **/
+  async triggerPluginUpdate(plugin) {
+    await this.#hooks.triggerHooks("pluginUpdate", { plugin });
+  }
   /**
    * Creates and initialises a new SDK instance by reading live on-chain state.
    *

package/dist/types/plugins/pools-history/ApyPlugin.d.ts

@@ -0,0 +1,70 @@
+import type { Address } from "viem";
+import type { IGearboxSDKPlugin } from "../../sdk/index.js";
+import { AddressMap, BasePlugin } from "../../sdk/index.js";
+import type { GetPoolsAPYResult } from "./pool-apy-types.js";
+import type { ApySnapshotState, Pool7DAgoState, Pools7DAgoStateHuman } from "./types.js";
+export interface ApyPluginState {
+    pools7DAgo: Record<Address, Pool7DAgoState>;
+    apySnapshot: ApySnapshotState;
+}
+export interface ApyPluginConstructorOptions {
+    apyUrl?: string;
+    /** TTL for the shared HTTP cache in milliseconds (default: same as timer interval) */
+    cacheTtlMs?: number;
+    timer?: PluginTimerOptions;
+}
+export interface ApyPluginLoadOptions {
+    /**
+     * When `false` and the plugin is already loaded, skips the multicall that loads
+     * pool diesel rates at the ~7d-ago block; only the APY snapshot is refreshed.
+     * Ignored on the first load (both datasets are always fetched initially).
+     */
+    loadPools7DAgo?: boolean;
+}
+export interface PluginTimerOptions {
+    /** Polling interval in milliseconds (default: 10 minutes) */
+    intervalMs?: number;
+    /** Callback fired after each successful refresh */
+    onChange?: () => void;
+    /**
+     * When `true`, each tick also refreshes 7d-ago pool state on-chain.
+     */
+    refreshPools7DAgoOnTick?: boolean;
+}
+export declare class ApyPlugin extends BasePlugin<ApyPluginState> implements IGearboxSDKPlugin<ApyPluginState> {
+    #private;
+    /**
+     * When `true`, the timer is started eagerly during the `attach` phase
+     * rather than waiting for an explicit `load` call.
+     **/
+    readonly startTimerOnAttach: boolean;
+    constructor(loadOnAttach?: boolean, startTimerOnAttach?: boolean, options?: ApyPluginConstructorOptions);
+    attach(): Promise<void>;
+    load(force?: boolean, loadOptions?: ApyPluginLoadOptions): Promise<ApyPluginState>;
+    get loaded(): boolean;
+    /**
+     * @throws if plugin is not loaded
+     */
+    get pools7DAgo(): AddressMap<Pool7DAgoState>;
+    /**
+     * @throws if plugin is not loaded
+     */
+    get apySnapshot(): ApySnapshotState;
+    /**
+     * Computes per-pool APY (current + 7d-ago) and points for all markets.
+     *
+     * @throws if plugin is not loaded
+     */
+    getPoolsAPY(): GetPoolsAPYResult;
+    /**
+     * 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?: PluginTimerOptions): () => void;
+    stopTimer(): void;
+    syncState(): Promise<void>;
+    stateHuman(_?: boolean): Pools7DAgoStateHuman[];
+    get state(): ApyPluginState;
+    hydrate(state: ApyPluginState): void;
+}

package/dist/types/plugins/pools-history/apy-cache.d.ts

@@ -0,0 +1,28 @@
+import type { Output } from "../../rewards/apy/index.js";
+import type { ILogger } from "../../sdk/index.js";
+/**
+ * Process-wide cache for the APY state-cache JSON.
+ *
+ * Multiple ApyPlugin instances (one per SDK / network) share the same
+ * cached HTTP response so that only **one** request is made per TTL window
+ * regardless of how many SDK instances exist.
+ *
+ * Concurrent callers that arrive while a fetch is already in flight
+ * are de-duplicated — they all await the same promise.
+ */
+export declare class ApyOutputCache {
+    #private;
+    private constructor();
+    /**
+     * Returns a shared cache instance for the given URL.
+     * The same instance is reused across all callers with identical URL.
+     */
+    static get(url: string, ttlMs: number, logger?: ILogger): ApyOutputCache;
+    /**
+     * Returns cached Output if fresh, otherwise fetches from the network.
+     * Concurrent calls are de-duplicated.
+     */
+    fetch(): Promise<Output<string, string> | undefined>;
+    /** Evicts all cached entries. Mainly useful for tests. */
+    static clearAll(): void;
+}

package/dist/types/plugins/pools-history/apy-parser.d.ts

@@ -0,0 +1,5 @@
+import type { DataResult, Output, PoolOutputDetails, TokenOutputDetails } from "../../rewards/apy/index.js";
+import type { GearStats, NetworkApyData } from "./types.js";
+export declare function numberToAPY(baseApy: number): number;
+export declare function parseGearStats(output: Output<string, string>): GearStats | null;
+export declare function parseNetworkApy(apyResp: DataResult<TokenOutputDetails<string>[]> | undefined, poolResp: DataResult<PoolOutputDetails<string>[]> | undefined): NetworkApyData | undefined;

package/dist/types/plugins/pools-history/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const APY_STATE_CACHE_URL = "https://state-cache.gearbox.foundation/apy-server/latest.json";
+export declare const DEFAULT_APY_INTERVAL_MS: number;

package/dist/types/plugins/pools-history/index.d.ts

@@ -1,2 +1,7 @@
-export * from "./Pools7DAgoPlugin.js";
+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";

package/dist/types/plugins/pools-history/pool-apy-types.d.ts

@@ -0,0 +1,39 @@
+import type { Address } from "viem";
+import type { ExternalApy as ExternalApySDK, PoolExtraApy, PoolPointsInfo } from "../../rewards/apy/index.js";
+export interface PoolBaseAPY {
+    type: "supplyAPY" | "tokenYield";
+    apy: number;
+}
+/**
+ * External APY enriched with the cumulative `totalValue`
+ * (base + extra + external).
+ */
+export interface PoolExternalAPY extends ExternalApySDK {
+    totalValue: number;
+}
+export interface PoolFullAPY {
+    totalAPY: number;
+    baseAPY: PoolBaseAPY[];
+    extraAPY: PoolExtraApy[];
+    extraAPYTotal: number;
+    externalAPY: PoolExternalAPY | undefined;
+}
+export interface PoolFullAPY7DAgo extends PoolFullAPY {
+    loading7DAgo: boolean;
+}
+export interface PoolPointsWithTips {
+    reward?: PoolPointsInfo<string>;
+    amount: string;
+    name: string;
+    tokenTitle?: string;
+    fullTip: string;
+}
+type AllPoolsAPY = Record<Address, PoolFullAPY>;
+type AllPoolsAPY7DAgo = Record<Address, PoolFullAPY7DAgo>;
+type AllPoolsPoints = Record<Address, PoolPointsWithTips[] | undefined>;
+export interface GetPoolsAPYResult {
+    data: AllPoolsAPY;
+    data7DAgo: AllPoolsAPY7DAgo;
+    points: AllPoolsPoints;
+}
+export {};

package/dist/types/plugins/pools-history/pool-apy-utils.d.ts

@@ -0,0 +1,71 @@
+import type { Address } from "viem";
+import type { ExternalApy, PoolExtraApy } from "../../rewards/apy/index.js";
+import type { PoolPointsBase } from "../../rewards/rewards/extra-apy.js";
+import type { TokensMeta } from "../../sdk/index.js";
+import type { PoolFullAPY, PoolFullAPY7DAgo, PoolPointsWithTips } from "./pool-apy-types.js";
+/**
+ * Collects extra APY entries for the given token addresses from the
+ * `poolExtraAPYList` map.
+ *
+ * In the client, `lookupAddresses` = [pool.address, ...pool.stakedDieselToken].
+ * The caller is responsible for providing the correct set of addresses.
+ */
+export declare function getPoolExtraAPY(lookupAddresses: Address[], poolExtraAPYList: Record<Address, PoolExtraApy[]> | undefined): PoolExtraApy[];
+/**
+ * Computes annualized supply APY based on diesel rate change over ~7 days.
+ *
+ * Returns a value in "percentage" units (e.g. 5 ≈ 5 %).
+ * Falls back to current on-chain `supplyRate` if 7d-ago diesel rate is
+ * missing or higher than the current rate.
+ */
+export declare function calculateSupplyApy7d(currentDieselRate: bigint, currentSupplyRate: bigint, dieselRate7DAgo: bigint): number;
+interface CalculatePoolFullAPYProps {
+    depositAPY: number;
+    underlyingAPY: number;
+    extraAPY: PoolExtraApy[] | undefined;
+    currentExternalList: ExternalApy[] | undefined;
+}
+/**
+ * Aggregates all APY components for a single pool.
+ *
+ * `depositAPY` and returned values are in "percentage" units (5 ≈ 5 %).
+ * `underlyingAPY` comes from `apyList` (scaled by `PERCENTAGE_FACTOR`),
+ *  so it is divided by `PERCENTAGE_FACTOR` here.
+ *
+ * External APY: first entry in `currentExternalList`, enriched with `totalValue`.
+ */
+export declare function calculatePoolFullAPY({ depositAPY, underlyingAPY, extraAPY, currentExternalList, }: CalculatePoolFullAPYProps): PoolFullAPY;
+interface CalculatePoolFullAPY7DAgoProps {
+    depositAPY: number;
+    /**
+     * Annualized supply APY from the ~7d diesel snapshot, in the same units as
+     * `depositAPY`.
+     *
+     * - `undefined` — 7d snapshot not loaded yet (`loading7DAgo: true`); supply
+     *   row uses `depositAPY`.
+     * - `null` — snapshot loaded but no numeric 7d supply; supply row uses
+     *   `depositAPY` (`||` semantics, same as client `pool7DAgo` with missing
+     *   `supplyAPY7DAgo`).
+     * - `number` — explicit 7d supply; `0` falls back to `depositAPY` via `||`.
+     */
+    supplyAPY7DAgo?: number | null;
+    poolAPY?: PoolFullAPY | null;
+}
+/**
+ * Computes the 7-days-ago APY snapshot for a pool.
+ *
+ * `supplyAPY7DAgo` replaces the current deposit APY in the base component;
+ * extra & external APY are kept from the "current" calculation.
+ */
+export declare function calculatePoolFullAPY7DAgo({ supplyAPY7DAgo, depositAPY, poolAPY, }: CalculatePoolFullAPY7DAgoProps): PoolFullAPY7DAgo;
+interface CalculatePoolPointsProps {
+    poolTokenSymbol: string | undefined;
+    points: PoolPointsBase[Address] | undefined;
+    tokensList: TokensMeta;
+}
+/**
+ * Transforms raw `PoolPointsBase` entries into consumer-friendly
+ * `PoolPointsWithTips` items with formatted amounts and tooltip strings.
+ */
+export declare function calculatePoolPoints({ poolTokenSymbol, points, tokensList, }: CalculatePoolPointsProps): PoolPointsWithTips[] | undefined;
+export {};

package/dist/types/plugins/pools-history/types.d.ts

@@ -1,4 +1,5 @@
 import type { Address } from "viem";
+import type { ExternalApy, ExtraCollateralAPY, GearAPYDetails, PointsInfo, PoolExtraApy, PoolPointsInfo } from "../../rewards/apy/index.js";
 import type { BaseContractStateHuman } from "../../sdk/index.js";
 export interface Pool7DAgoState {
     pool: Address;
@@ -7,3 +8,30 @@ export interface Pool7DAgoState {
 export interface Pools7DAgoStateHuman extends BaseContractStateHuman {
     dieselRate: bigint;
 }
+export interface FarmRewardInfo {
+    address: Address;
+    symbol: string;
+    rewardToken: Address;
+    rewardSymbol: string;
+    token: Address;
+    duration: bigint;
+    finished: bigint;
+    reward: bigint;
+    balance: bigint;
+}
+export interface NetworkApyData {
+    apyList: Record<Address, number> | undefined;
+    extraCollateralAPYList: Record<Address, Record<Address, ExtraCollateralAPY>> | undefined;
+    pointsList: Record<Address, PointsInfo<string>> | undefined;
+    extraCollateralPointsList: Record<Address, Record<Address, PointsInfo<string>>> | undefined;
+    poolRewardsList: Record<Address, Array<PoolPointsInfo<string>>> | undefined;
+    tokenExtraRewardsList: Record<Address, Array<FarmRewardInfo>> | undefined;
+    poolExternalAPYList: Record<Address, Array<ExternalApy>> | undefined;
+    poolExtraAPYList: Record<Address, Array<PoolExtraApy>> | undefined;
+}
+export type GearStats = Omit<GearAPYDetails, "lastUpdated">;
+export interface ApySnapshotState {
+    apy: NetworkApyData;
+    gearStats: GearStats | null;
+    timestamp: string;
+}

package/dist/types/rewards/rewards/api.d.ts

@@ -1,6 +1,15 @@
 import type { Address } from "viem";
 import { type NetworkType } from "../../sdk/index.js";
-import type { PoolData } from "./common.js";
+export interface PoolData {
+    address: Address;
+    version: number;
+    underlyingToken: Address;
+    dieselRateRay: bigint;
+    dieselToken: Address;
+    stakedDieselToken: Address[];
+    stakedDieselToken_old: Address[];
+    expectedLiquidity: bigint;
+}
 export interface GearboxExtraMerkleLmReward {
     pool: Address;
     poolToken: Address;

package/dist/types/rewards/rewards/common.d.ts

@@ -4,13 +4,3 @@ export interface TokenData {
     symbol: string;
     decimals: number;
 }
-export interface PoolData {
-    address: Address;
-    version: number;
-    underlyingToken: Address;
-    dieselRateRay: bigint;
-    dieselToken: Address;
-    stakedDieselToken: Address[];
-    stakedDieselToken_old: Address[];
-    expectedLiquidity: bigint;
-}

package/dist/types/rewards/rewards/extra-apy.d.ts

@@ -1,13 +1,12 @@
 import type { Address } from "viem";
-import { type Asset, type NetworkType } from "../../sdk/index.js";
+import { type Asset, type MarketSuite, type NetworkType, type TokensMeta } from "../../sdk/index.js";
 import type { PoolPointsInfo } from "../index.js";
-import type { PoolData, TokenData } from "./common.js";
-type PartialPool = Pick<PoolData, "expectedLiquidity" | "underlyingToken" | "address">;
+import type { TokenData } from "./common.js";
 export interface GetPointsByPoolProps {
     poolRewards: Record<Address, Array<PoolPointsInfo<string>>>;
     totalTokenBalances: Record<Address, Asset>;
-    pools: Array<PartialPool>;
-    tokensList: Record<Address, TokenData>;
+    pools: MarketSuite[];
+    tokensList: TokensMeta;
 }
 export interface GetTotalTokensOnProtocolProps {
     tokensToCheck: Array<Address>;
@@ -27,4 +26,3 @@ export declare class PoolPointsAPI {
     static getPointsByPool({ poolRewards, totalTokenBalances, pools, tokensList, }: GetPointsByPoolProps): PoolPointsBase;
     private static getPoolTokenPoints;
 }
-export {};