@gearbox-protocol/sdk 13.6.0-kyc.7 → 13.6.0

package/dist/cjs/sdk/pools/PoolService.js

@@ -22,7 +22,6 @@ __export(PoolService_exports, {
 });
 module.exports = __toCommonJS(PoolService_exports);
 var import_generated = require("../../abi/310/generated.js");
-var import_iERC20 = require("../../abi/iERC20.js");
 var import_iERC20ZapperDeposits = require("../../abi/iERC20ZapperDeposits.js");
 var import_iETHZapperDeposits = require("../../abi/iETHZapperDeposits.js");
 var import_iZapper = require("../../abi/iZapper.js");
@@ -31,73 +30,28 @@ var import_constants = require("../constants/index.js");
 var import_utils = require("../utils/index.js");
 class PoolService extends import_base.SDKConstruct {
   /**
-   * {@inheritDoc IPoolsService.getDepositTokensIn}
+   * @inheritdoc IPoolsService.getDepositTokensIn
    */
   getDepositTokensIn(pool) {
-    const underlying = this.#describeUnderlying(pool);
-    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
-      switch (underlying.contractType) {
-        case import_base.KYC_UNDERLYING_DEFAULT:
-          return this.#depositTokensIn(pool, false);
-        case import_base.KYC_UNDERLYING_ON_DEMAND:
-          return [underlying.asset];
-      }
-    }
     return this.#depositTokensIn(pool, true);
   }
   /**
-   * {@inheritDoc IPoolsService.getDepositTokensOut}
+   * @inheritdoc IPoolsService.getDepositTokensOut
    */
   getDepositTokensOut(pool, tokenIn) {
-    const underlying = this.#describeUnderlying(pool);
-    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
-      switch (underlying.contractType) {
-        case import_base.KYC_UNDERLYING_DEFAULT:
-          return this.#depositTokensOut(pool, tokenIn, false);
-        case import_base.KYC_UNDERLYING_ON_DEMAND:
-          return [];
-      }
-    }
     return this.#depositTokensOut(pool, tokenIn, true);
   }
   /**
-   * {@inheritDoc IPoolsService.getDepositMetadata}
+   * @inheritdoc IPoolsService.getDepositMetadata
    */
   getDepositMetadata(pool, tokenIn, tokenOut) {
-    const underlying = this.#describeUnderlying(pool);
-    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
-      switch (underlying.contractType) {
-        case import_base.KYC_UNDERLYING_DEFAULT: {
-          return this.#depositMetadata(
-            "kyc-default",
-            pool,
-            tokenIn,
-            tokenOut,
-            false
-          );
-        }
-        case import_base.KYC_UNDERLYING_ON_DEMAND:
-          return {
-            zapper: void 0,
-            approveTarget: underlying.liquidityProvider.addr,
-            permissible: false,
-            type: "kyc-on-demand"
-          };
-      }
-    }
     return this.#depositMetadata("classic", pool, tokenIn, tokenOut, true);
   }
   /**
-   * {@inheritDoc IPoolsService.addLiquidity}
+   * @inheritdoc IPoolsService.addLiquidity
    */
   addLiquidity(props) {
     const { collateral, meta, permit, referralCode, pool, wallet } = props;
-    const underlying = this.#describeUnderlying(pool);
-    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
-      if (underlying.contractType === import_base.KYC_UNDERLYING_ON_DEMAND) {
-        return void 0;
-      }
-    }
     const { zapper } = meta;
     if (zapper && (0, import_utils.hexEq)(zapper.tokenIn.addr, import_constants.NATIVE_ADDRESS)) {
       return {
@@ -137,51 +91,22 @@ class PoolService extends import_base.SDKConstruct {
     }
   }
   /**
-   * {@inheritDoc IPoolsService.getWithdrawalTokensIn}
+   * @inheritdoc IPoolsService.getWithdrawalTokensIn
    */
   getWithdrawalTokensIn(pool) {
-    const underlying = this.#describeUnderlying(pool);
-    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
-      switch (underlying.contractType) {
-        case import_base.KYC_UNDERLYING_DEFAULT:
-          return this.#withdrawalTokensIn(pool, false);
-        case import_base.KYC_UNDERLYING_ON_DEMAND:
-          return [];
-      }
-    }
     return this.#withdrawalTokensIn(pool, true);
   }
   /**
-   * {@inheritDoc IPoolsService.getWithdrawalTokensOut}
+   * @inheritdoc IPoolsService.getWithdrawalTokensOut
    */
   getWithdrawalTokensOut(pool, tokenIn) {
-    const underlying = this.#describeUnderlying(pool);
-    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
-      switch (underlying.contractType) {
-        case import_base.KYC_UNDERLYING_DEFAULT:
-          return this.#withdrawalTokensOut(pool, tokenIn, false);
-        case import_base.KYC_UNDERLYING_ON_DEMAND:
-          return [underlying.asset];
-      }
-    }
     return this.#withdrawalTokensOut(pool, tokenIn, true);
   }
   /**
-   * {@inheritDoc IPoolsService.removeLiquidity}
+   * @inheritdoc IPoolsService.removeLiquidity
    */
   removeLiquidity(props) {
     const { pool, amount, meta, wallet, permit } = props;
-    const underlying = this.#describeUnderlying(pool);
-    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
-      if (underlying.contractType === import_base.KYC_UNDERLYING_ON_DEMAND) {
-        return {
-          abi: import_iERC20.ierc20Abi,
-          functionName: "approve",
-          args: [underlying.liquidityProvider, 0n],
-          target: underlying.asset
-        };
-      }
-    }
     if (meta.zapper) {
       return permit ? {
         target: meta.zapper.baseParams.addr,
@@ -210,30 +135,9 @@ class PoolService extends import_base.SDKConstruct {
     };
   }
   /**
-   * {@inheritDoc IPoolsService.getWithdrawalMetadata}
+   * @inheritdoc IPoolsService.getWithdrawalMetadata
    */
   getWithdrawalMetadata(pool, tokenIn, tokenOut) {
-    const underlying = this.#describeUnderlying(pool);
-    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
-      switch (underlying.contractType) {
-        case import_base.KYC_UNDERLYING_DEFAULT: {
-          return this.#withdrawalMetadata(
-            "kyc-default",
-            pool,
-            tokenIn,
-            tokenOut,
-            false
-          );
-        }
-        case import_base.KYC_UNDERLYING_ON_DEMAND:
-          return {
-            zapper: void 0,
-            approveTarget: void 0,
-            permissible: false,
-            type: "kyc-on-demand"
-          };
-      }
-    }
     return this.#withdrawalMetadata("classic", pool, tokenIn, tokenOut, true);
   }
   /**
@@ -393,6 +297,8 @@ class PoolService extends import_base.SDKConstruct {
       zapper,
       // Approval target is zapper when routed, otherwise the pool contract.
       approveTarget: zapper?.baseParams.addr ?? pool.pool.address,
+      // TODO: instead of permissible, return permitType depending on tokenIn
+      // "none" | "eip2612" | "dai_like";
       permissible: !!zapper && !(0, import_utils.hexEq)(tokenIn, import_constants.NATIVE_ADDRESS),
       type
     };
@@ -420,6 +326,8 @@ class PoolService extends import_base.SDKConstruct {
       zapper,
       // Approval target exists only for zapper-based withdrawals.
       approveTarget: zapper?.baseParams.addr,
+      // TODO: instead of permissible, return permitType depending on tokenIn
+      // "none" | "eip2612" | "dai_like";
       permissible: !!zapper,
       type
     };

package/dist/cjs/sdk/utils/viem/index.js

@@ -16,7 +16,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var viem_exports = {};
 module.exports = __toCommonJS(viem_exports);
 __reExport(viem_exports, require("./cast.js"), module.exports);
-__reExport(viem_exports, require("./executeDelegatedMulticalls.js"), module.exports);
 __reExport(viem_exports, require("./getLogsPaginated.js"), module.exports);
 __reExport(viem_exports, require("./getLogsSafe.js"), module.exports);
 __reExport(viem_exports, require("./sendRawTx.js"), module.exports);
@@ -25,7 +24,6 @@ __reExport(viem_exports, require("./simulateWithPriceUpdates.js"), module.export
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./cast.js"),
-  ...require("./executeDelegatedMulticalls.js"),
   ...require("./getLogsPaginated.js"),
   ...require("./getLogsSafe.js"),
   ...require("./sendRawTx.js"),

package/dist/cjs/sdk/utils/viem/simulateWithPriceUpdates.js

@@ -24,6 +24,8 @@ __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");
@@ -53,6 +55,41 @@ 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 = [
@@ -173,8 +210,8 @@ function getSimulateWithPriceUpdatesError(cause, priceUpdates, calls, results, r
     return [extractCallError(result), p.pretty, tsValid].filter(Boolean).join(" ");
   });
   const prettyCalls = callsResults.map((c, i) => {
-    const call = calls[i];
-    return [extractCallError(c), `${call.address}.${call.functionName}`].filter(Boolean).join(" ");
+    const call2 = calls[i];
+    return [extractCallError(c), `${call2.address}.${call2.functionName}`].filter(Boolean).join(" ");
   });
   if (results[0]?.status === "failure") {
     prettyCalls.unshift(

package/dist/esm/dev/AccountOpener.js

@@ -6,7 +6,7 @@ import {
   parseEventLogs
 } from "viem";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
-import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
+import { iCreditFacadeV310Abi, iPoolV310Abi } from "../abi/310/generated.js";
 import { ierc20Abi } from "../abi/iERC20.js";
 import {
   ADDRESS_0X0,
@@ -15,7 +15,6 @@ import {
   childLogger,
   MAX_UINT256,
   PERCENTAGE_FACTOR,
-  PoolService,
   SDKConstruct,
   sendRawTx
 } from "../sdk/index.js";
@@ -44,7 +43,6 @@ class AccountOpener extends SDKConstruct {
   #minDebtMultiplier;
   #allowMint;
   #leverageDelta;
-  #poolService;
   constructor(service, options_ = {}) {
     super(service.sdk);
     const {
@@ -70,7 +68,6 @@ class AccountOpener extends SDKConstruct {
     this.#poolDepositMultiplier = BigInt(poolDepositMultiplier);
     this.#minDebtMultiplier = BigInt(minDebtMultiplier);
     this.#leverageDelta = BigInt(leverageDelta);
-    this.#poolService = new PoolService(service.sdk);
     this.#logger?.info(
       {
         borrower: privateKeyToAccount(this.borrowerKey).address,
@@ -108,10 +105,6 @@ class AccountOpener extends SDKConstruct {
       },
       "opening credit accounts"
     );
-    await Promise.all([
-      this.sdk.tokensMeta.loadTokenData(),
-      this.sdk.marketRegister.loadZappers()
-    ]);
     let deposits = [];
     if (depositIntoPools) {
       try {
@@ -463,34 +456,9 @@ class AccountOpener extends SDKConstruct {
       this.#logger?.debug(
         `depositor balance in underlying: ${this.sdk.tokensMeta.formatBN(pool.underlying, allowance, { symbol: true })}`
       );
-      const tokensOut = this.#poolService.getDepositTokensOut(
-        address,
-        underlying
-      );
-      this.#logger?.debug(
-        { tokensOut: tokensOut.map((t) => this.labelAddress(t)) },
-        "deposit tokens out"
-      );
-      if (tokensOut.length === 0) {
-        throw new Error(`no tokens out found for pool ${poolName}`);
-      }
-      const tokenOut = tokensOut[0];
-      const metadata = this.#poolService.getDepositMetadata(
-        address,
-        underlying,
-        tokenOut
-      );
-      this.logger?.debug(
-        {
-          underlying: this.labelAddress(underlying),
-          tokenOut: this.labelAddress(tokenOut),
-          ...metadata
-        },
-        "pool deposit metadata"
-      );
       txHash = await this.#anvil.writeContract({
         account: depositor,
-        address: metadata.approveTarget,
+        address: underlying,
         abi: ierc20Abi,
         functionName: "approve",
         args: [address, allowance],
@@ -507,21 +475,12 @@ class AccountOpener extends SDKConstruct {
       this.#logger?.debug(
         `depositor approved underlying for pool ${poolName}: ${txHash}`
       );
-      const depositCall = this.#poolService.addLiquidity({
-        collateral: { token: underlying, balance: amount },
-        pool: address,
-        wallet: depositor.address,
-        meta: metadata
-      });
-      if (!depositCall) {
-        throw new Error(`no deposit call could be created for ${poolName}`);
-      }
       txHash = await this.#anvil.writeContract({
         account: depositor,
-        address: depositCall.target,
-        abi: depositCall.abi,
-        functionName: depositCall.functionName,
-        args: depositCall.args,
+        address,
+        abi: iPoolV310Abi,
+        functionName: "deposit",
+        args: [amount, depositor.address],
         chain: this.#anvil.chain
       });
       receipt = await this.#anvil.waitForTransactionReceipt({ hash: txHash });

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.TRADERJOE_ROUTER]: {
+  [AdapterType.TRADER_JOE_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.TRADERJOE_ROUTER]: {
+  [AdapterType.TRADER_JOE_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::TRADERJOE_ROUTER":
+    case "ADAPTER::TRADER_JOE_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["TRADERJOE_ROUTER"] = "TRADERJOE_ROUTER";
+  AdapterType2["TRADER_JOE_ROUTER"] = "TRADER_JOE_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/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
+};