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

package/dist/esm/plugins/apy/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/types/src/plugins/apy/ApyPlugin.d.ts

@@ -0,0 +1,46 @@
+import type { Address } from "viem";
+import type { IOnchainSDKPlugin } 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: 10 minutes, see `DEFAULT_APY_INTERVAL_MS`) */
+    cacheTtlMs?: number;
+}
+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 declare class ApyPlugin extends BasePlugin<ApyPluginState> implements IOnchainSDKPlugin<ApyPluginState> {
+    #private;
+    constructor(loadOnAttach?: boolean, options?: ApyPluginConstructorOptions);
+    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;
+    syncState(): Promise<void>;
+    stateHuman(_?: boolean): Pools7DAgoStateHuman[];
+    get state(): ApyPluginState;
+    hydrate(state: ApyPluginState): void;
+}

package/dist/types/src/plugins/apy/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/src/plugins/apy/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/src/plugins/apy/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/src/plugins/apy/index.d.ts

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

package/dist/types/src/plugins/apy/pool-apy-types.d.ts

@@ -0,0 +1,41 @@
+import type { Address } from "viem";
+import type { ExternalApy as ExternalApySDK, PoolExtraApy, PoolPointsInfo } from "../../rewards/apy/index.js";
+import type { PoolPointsBase } from "../../rewards/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;
+    pointsBase: PoolPointsBase;
+    points: AllPoolsPoints;
+}
+export {};

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

@@ -0,0 +1,73 @@
+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 { AddressMap } 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: AddressMap<{
+        decimals: number;
+    }>;
+}
+/**
+ * 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/src/plugins/apy/types.d.ts

@@ -0,0 +1,37 @@
+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;
+    dieselRate: bigint;
+}
+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/src/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/src/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/src/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 {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "14.0.0-next.1",
+  "version": "14.0.0-next.2",
   "description": "Gearbox SDK",
   "license": "MIT",
   "main": "./dist/cjs/sdk/index.js",

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

@@ -1,108 +0,0 @@
-"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 Pools7DAgoPlugin_exports = {};
-__export(Pools7DAgoPlugin_exports, {
-  Pools7DAgoPlugin: () => Pools7DAgoPlugin
-});
-module.exports = __toCommonJS(Pools7DAgoPlugin_exports);
-var import_marketCompressor = require("../../abi/compressors/marketCompressor.js");
-var import_sdk = require("../../sdk/index.js");
-const MAP_LABEL = "pools7DAgo";
-class Pools7DAgoPlugin extends import_sdk.BasePlugin {
-  #pools7DAgo;
-  async load(force) {
-    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.sdk.logger?.debug(
-      `loading pools 7d ago with market compressor ${marketCompressorAddress}`
-    );
-    const markets = this.sdk.marketRegister.markets;
-    const resp = await 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
-    });
-    this.#pools7DAgo = new import_sdk.AddressMap(void 0, MAP_LABEL);
-    resp.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.sdk.logger?.error(
-          `failed to load pools 7d ago for market configurator ${this.labelAddress(cfg)} and pool ${this.labelAddress(pool)}: ${r.error}`
-        );
-      }
-    });
-    return this.state;
-  }
-  get loaded() {
-    return !!this.#pools7DAgo;
-  }
-  /**
-   * Returns a map of pool addresses to minified pool 7d ago state
-   * @throws if pool 7d ago plugin is not attached
-   */
-  get pools7DAgo() {
-    if (!this.#pools7DAgo) {
-      throw new Error("pools 7d ago plugin not attached");
-    }
-    return this.#pools7DAgo;
-  }
-  stateHuman(_) {
-    return this.pools7DAgo.values().flatMap((p) => ({
-      address: p.pool,
-      version: this.version,
-      dieselRate: p.dieselRate
-    }));
-  }
-  get state() {
-    return {
-      pools7DAgo: this.pools7DAgo.asRecord()
-    };
-  }
-  hydrate(state) {
-    this.#pools7DAgo = new import_sdk.AddressMap(
-      Object.entries(state.pools7DAgo),
-      MAP_LABEL
-    );
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Pools7DAgoPlugin
-});

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

@@ -1,90 +0,0 @@
-import { marketCompressorAbi } from "../../abi/compressors/marketCompressor.js";
-import {
-  AddressMap,
-  AP_MARKET_COMPRESSOR,
-  BasePlugin,
-  BLOCKS_PER_WEEK_BY_NETWORK,
-  VERSION_RANGE_310
-} from "../../sdk/index.js";
-const MAP_LABEL = "pools7DAgo";
-class Pools7DAgoPlugin extends BasePlugin {
-  #pools7DAgo;
-  async load(force) {
-    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.sdk.logger?.debug(
-      `loading pools 7d ago with market compressor ${marketCompressorAddress}`
-    );
-    const markets = this.sdk.marketRegister.markets;
-    const resp = await 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
-    });
-    this.#pools7DAgo = new AddressMap(void 0, MAP_LABEL);
-    resp.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.sdk.logger?.error(
-          `failed to load pools 7d ago for market configurator ${this.labelAddress(cfg)} and pool ${this.labelAddress(pool)}: ${r.error}`
-        );
-      }
-    });
-    return this.state;
-  }
-  get loaded() {
-    return !!this.#pools7DAgo;
-  }
-  /**
-   * Returns a map of pool addresses to minified pool 7d ago state
-   * @throws if pool 7d ago plugin is not attached
-   */
-  get pools7DAgo() {
-    if (!this.#pools7DAgo) {
-      throw new Error("pools 7d ago plugin not attached");
-    }
-    return this.#pools7DAgo;
-  }
-  stateHuman(_) {
-    return this.pools7DAgo.values().flatMap((p) => ({
-      address: p.pool,
-      version: this.version,
-      dieselRate: p.dieselRate
-    }));
-  }
-  get state() {
-    return {
-      pools7DAgo: this.pools7DAgo.asRecord()
-    };
-  }
-  hydrate(state) {
-    this.#pools7DAgo = new AddressMap(
-      Object.entries(state.pools7DAgo),
-      MAP_LABEL
-    );
-  }
-}
-export {
-  Pools7DAgoPlugin
-};

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

@@ -1,2 +0,0 @@
-export * from "./Pools7DAgoPlugin.js";
-export * from "./types.js";