@gearbox-protocol/sdk 3.0.0-vfourabi.1 → 3.0.0-vfourabi.3

package/src/sdk/market/pricefeeds/PriceFeedsRegister.ts

@@ -0,0 +1,293 @@
+import {
+  type Address,
+  getChainContractAddress,
+  type Hex,
+  multicall3Abi,
+} from "viem";
+
+import { iMarketCompressorAbi } from "../../../abi/compressors";
+import type { BaseParams, PriceFeedTreeNode } from "../../base";
+import { SDKConstruct } from "../../base";
+import { ADDRESS_0X0, AP_MARKET_COMPRESSOR } from "../../constants";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { ILogger, RawTx } from "../../types";
+import {
+  AddressMap,
+  bytes32ToString,
+  childLogger,
+  createRawTx,
+} from "../../utils";
+import type { IHooks } from "../../utils/internal";
+import { Hooks } from "../../utils/internal";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+import { BalancerStablePriceFeedContract } from "./BalancerStablePriceFeed";
+import { BalancerWeightedPriceFeedContract } from "./BalancerWeightedPriceFeed";
+import { BoundedPriceFeedContract } from "./BoundedPriceFeed";
+import { ChainlinkPriceFeedContract } from "./ChainlinkPriceFeed";
+import { CompositePriceFeedContract } from "./CompositePriceFeed";
+import { CurveCryptoPriceFeedContract } from "./CurveCryptoPriceFeed";
+import { CurveStablePriceFeedContract } from "./CurveStablePriceFeed";
+import { CurveUSDPriceFeedContract } from "./CurveUSDPriceFeed";
+import { Erc4626PriceFeedContract } from "./Erc4626PriceFeed";
+import { MellowLRTPriceFeedContract } from "./MellowLRTPriceFeed";
+import { PendleTWAPPTPriceFeed } from "./PendleTWAPPTPriceFeed";
+import { RedstonePriceFeedContract } from "./RedstonePriceFeed";
+import { RedstoneUpdater } from "./RedstoneUpdater";
+import type {
+  IPriceFeedContract,
+  PriceFeedContractType,
+  UpdatePriceFeedsResult,
+} from "./types";
+import { WstETHPriceFeedContract } from "./WstETHPriceFeed";
+import { YearnPriceFeedContract } from "./YearnPriceFeed";
+import { ZeroPriceFeedContract } from "./ZeroPriceFeed";
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export type PriceFeedRegisterHooks = {
+  /**
+   * Emitted when transactions to update price feeds have been generated, but before they're used anywhere
+   */
+  updatesGenerated: [UpdatePriceFeedsResult];
+};
+
+/**
+ * PriceFeedRegister acts as a chain-level cache to avoid creating multiple contract instances.
+ * It's reused by PriceOracles belonging to different markets
+ *
+ **/
+export class PriceFeedRegister
+  extends SDKConstruct
+  implements IHooks<PriceFeedRegisterHooks>
+{
+  public readonly logger?: ILogger;
+  readonly #hooks = new Hooks<PriceFeedRegisterHooks>();
+  #feeds = new AddressMap<IPriceFeedContract>(undefined, "priceFeeds");
+  public readonly redstoneUpdater: RedstoneUpdater;
+
+  constructor(sdk: GearboxSDK) {
+    super(sdk);
+    this.logger = childLogger("PriceFeedRegister", sdk.logger);
+    this.redstoneUpdater = new RedstoneUpdater(sdk);
+  }
+
+  public addHook = this.#hooks.addHook.bind(this.#hooks);
+  public removeHook = this.#hooks.removeHook.bind(this.#hooks);
+
+  /**
+   * Returns RawTxs to update price feeds
+   * @param priceFeeds top-level price feeds, actual updatable price feeds will be derived. If not provided will use all price feeds that are attached
+   * @param logContext extra information for logging
+   * @returns
+   */
+  public async generatePriceFeedsUpdateTxs(
+    priceFeeds?: IPriceFeedContract[],
+    logContext: Record<string, any> = {},
+  ): Promise<UpdatePriceFeedsResult> {
+    const updateables = priceFeeds
+      ? priceFeeds.flatMap(pf => pf.updatableDependencies())
+      : this.#feeds.values();
+    return this.#generatePriceFeedsUpdateTxs(updateables, logContext);
+  }
+
+  public has(address: Address): boolean {
+    return this.#feeds.has(address);
+  }
+
+  public mustGet(address: Address): IPriceFeedContract {
+    return this.#feeds.mustGet(address);
+  }
+
+  public getOrCreate(data: PriceFeedTreeNode): IPriceFeedContract {
+    const existing = this.#feeds.get(data.baseParams.addr);
+    // it's possible to have non-loaded price feed here first from MarketCompressor.getUpdatablePriceFeeds
+    // we ovewrite them using full tree nodes
+    if (existing?.loaded) {
+      return existing;
+    }
+    const feed = this.create(data);
+    this.#feeds.upsert(data.baseParams.addr, feed);
+    return feed;
+  }
+
+  /**
+   * Loads PARTIAL information about all updatable price feeds from MarketCompressor
+   * This can later be used to load price feed updates
+   */
+  public async preloadUpdatablePriceFeeds(
+    marketConfigurators?: Address[],
+    pools?: Address[],
+  ): Promise<void> {
+    const feedsData = await this.#loadUpdatablePriceFeeds(
+      marketConfigurators,
+      pools,
+    );
+    for (const data of feedsData) {
+      const feed = this.create({ baseParams: data });
+      this.#feeds.upsert(feed.address, feed);
+    }
+  }
+
+  /**
+   * Generates price update transaction via multicall3 without any market data knowledge
+   * @param marketConfigurators
+   * @param pools
+   * @returns
+   */
+  public async getUpdatePriceFeedsTx(
+    marketConfigurators?: Address[],
+    pools?: Address[],
+  ): Promise<RawTx> {
+    const feedsData = await this.#loadUpdatablePriceFeeds(
+      marketConfigurators,
+      pools,
+    );
+    const feeds = feedsData.map(data => this.create({ baseParams: data }));
+    const updates = await this.#generatePriceFeedsUpdateTxs(feeds);
+
+    return createRawTx(
+      getChainContractAddress({
+        chain: this.sdk.provider.chain,
+        contract: "multicall3",
+      }),
+      {
+        abi: multicall3Abi,
+        functionName: "aggregate3",
+        args: [
+          updates.txs.map(tx => ({
+            target: tx.to,
+            allowFailure: false,
+            callData: tx.callData,
+          })),
+        ],
+      },
+    );
+  }
+
+  async #generatePriceFeedsUpdateTxs(
+    updateables: IPriceFeedContract[],
+    logContext: Record<string, any> = {},
+  ): Promise<UpdatePriceFeedsResult> {
+    const txs: RawTx[] = [];
+    const redstonePFs: RedstonePriceFeedContract[] = [];
+
+    for (const pf of updateables) {
+      if (pf instanceof RedstonePriceFeedContract) {
+        redstonePFs.push(pf);
+      }
+    }
+
+    let maxTimestamp = 0;
+    if (redstonePFs.length > 0) {
+      const redstoneUpdates = await this.redstoneUpdater.getUpdateTxs(
+        redstonePFs,
+        logContext,
+      );
+      for (const { tx, timestamp } of redstoneUpdates) {
+        if (timestamp > maxTimestamp) {
+          maxTimestamp = timestamp;
+        }
+        txs.push(tx);
+      }
+    }
+
+    const result: UpdatePriceFeedsResult = { txs, timestamp: maxTimestamp };
+    this.logger?.debug(
+      logContext,
+      `generated ${txs.length} price feed update transactions, timestamp: ${maxTimestamp}`,
+    );
+    if (txs.length) {
+      await this.#hooks.triggerHooks("updatesGenerated", result);
+    }
+    return result;
+  }
+
+  async #loadUpdatablePriceFeeds(
+    marketConfigurators?: Address[],
+    pools?: Address[],
+  ): Promise<readonly BaseParams[]> {
+    const marketCompressorAddress = this.sdk.addressProvider.getAddress(
+      AP_MARKET_COMPRESSOR,
+      3_10,
+    );
+    const configurators =
+      marketConfigurators ??
+      this.sdk.marketRegister.marketConfigurators.map(mc => mc.address);
+    this.logger?.debug(
+      { configurators, pools },
+      "calling getUpdatablePriceFeeds",
+    );
+    const result = await this.provider.publicClient.readContract({
+      address: marketCompressorAddress,
+      abi: iMarketCompressorAbi,
+      functionName: "getUpdatablePriceFeeds",
+      args: [
+        {
+          configurators,
+          pools: pools ?? [],
+          underlying: ADDRESS_0X0,
+        },
+      ],
+      // It's passed as ...rest in viem readContract action, but this might change
+      // @ts-ignore
+      // gas: 500_000_000n,
+    });
+    this.logger?.debug(`loaded ${result.length} updatable price feeds`);
+    return result;
+  }
+
+  public create(data: PartialPriceFeedTreeNode): IPriceFeedContract {
+    const contractType = bytes32ToString(
+      data.baseParams.contractType as Hex,
+    ) as PriceFeedContractType;
+
+    switch (contractType) {
+      case "PRICE_FEED::EXTERNAL":
+        return new ChainlinkPriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::YEARN":
+        return new YearnPriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::CURVE_STABLE":
+        return new CurveStablePriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::WSTETH":
+        return new WstETHPriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::BOUNDED":
+        return new BoundedPriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::COMPOSITE":
+        return new CompositePriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::BALANCER_STABLE":
+        return new BalancerStablePriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::BALANCER_WEIGHTED":
+        return new BalancerWeightedPriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::CURVE_CRYPTO":
+        return new CurveCryptoPriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::REDSTONE":
+        return new RedstonePriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::ERC4626":
+        return new Erc4626PriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::CURVE_USD":
+        return new CurveUSDPriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::ZERO":
+        return new ZeroPriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::MELLOW_LRT":
+        return new MellowLRTPriceFeedContract(this.sdk, data);
+
+      case "PRICE_FEED::PENDLE_PT_TWAP":
+        return new PendleTWAPPTPriceFeed(this.sdk, data);
+
+      default:
+        throw new Error(`Price feed type ${contractType} not supported, `);
+    }
+  }
+}

package/src/sdk/market/pricefeeds/RedstonePriceFeed.ts

@@ -0,0 +1,65 @@
+import type { Hex } from "viem";
+import { bytesToString, decodeAbiParameters, toBytes } from "viem";
+
+import { redstonePriceFeedAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { RedstonePriceFeedStateHuman } from "../../types";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+import { AbstractPriceFeedContract } from "./AbstractPriceFeed";
+
+type abi = typeof redstonePriceFeedAbi;
+
+export class RedstonePriceFeedContract extends AbstractPriceFeedContract<abi> {
+  public readonly dataServiceId: string;
+  public readonly dataId: string;
+  public readonly signers: Hex[];
+  public readonly signersThreshold: number;
+
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    super(sdk, {
+      ...args,
+      name: `RedstonePriceFeed`,
+      abi: redstonePriceFeedAbi,
+    });
+    const decoder = decodeAbiParameters(
+      [
+        { type: "address" }, //  [0]: pf.token(),
+        { type: "bytes32" }, //  [1]: pf.dataFeedId(),
+        { type: "address" }, //  [2]: pf.signerAddress0(),
+        { type: "address" }, //  [3]: pf.signerAddress1(),
+        { type: "address" }, //  [4]: pf.signerAddress2(),
+        { type: "address" }, //  [5]: pf.signerAddress3(),
+        { type: "address" }, //  [6]: pf.signerAddress4(),
+        { type: "address" }, //  [7]: pf.signerAddress5()
+        { type: "address" }, //  [8]: pf.signerAddress6(),
+        { type: "address" }, //  [9]: pf.signerAddress7(),
+        { type: "address" }, // [10]: pf.signerAddress8(),
+        { type: "address" }, // [11]: pf.signerAddress9(),
+        { type: "uint8" }, //   [12]: pf.getUniqueSignersThreshold()
+        { type: "uint128" }, // [13]: pf.lastPrice(),
+        { type: "uint40" }, //  [14]: pf.lastPayloadTimestamp()
+      ],
+      args.baseParams.serializedParams,
+    );
+
+    this.dataId = bytesToString(toBytes(decoder[1])).replaceAll("\x00", "");
+    this.signers = decoder.slice(2, 11) as Hex[];
+    this.signersThreshold = Number(decoder[12]);
+    this.dataServiceId = ["GMX", "BAL"].includes(this.dataId)
+      ? "redstone-arbitrum-prod"
+      : "redstone-primary-prod";
+  }
+
+  public override stateHuman(
+    raw = true,
+  ): Omit<RedstonePriceFeedStateHuman, "stalenessPeriod"> {
+    return {
+      ...super.stateHuman(raw),
+      contractType: "PRICE_FEED::REDSTONE",
+      dataId: this.dataId,
+      signers: this.signers,
+      signersThreshold: this.signersThreshold,
+      skipCheck: true,
+    };
+  }
+}

package/src/sdk/market/pricefeeds/RedstoneUpdater.ts

@@ -0,0 +1,304 @@
+/* eslint-disable accessor-pairs */
+import { DataServiceWrapper } from "@redstone-finance/evm-connector";
+import type { SignedDataPackage } from "@redstone-finance/protocol";
+import { RedstonePayload } from "@redstone-finance/protocol";
+import type { Address, Hex } from "viem";
+import { encodeAbiParameters, toBytes } from "viem";
+
+import { SDKConstruct } from "../../base";
+import type { GearboxSDK } from "../../GearboxSDK";
+import type { ILogger, RawTx } from "../../types";
+import { childLogger, retry } from "../../utils";
+import type { RedstonePriceFeedContract } from "./RedstonePriceFeed";
+
+interface TimestampedCalldata {
+  dataFeedId: string;
+  data: `0x${string}`;
+  timestamp: number;
+}
+
+interface UpdatePFTask {
+  priceFeed: Address;
+  tx: RawTx;
+  timestamp: number;
+}
+
+/**
+ * Class to update multiple redstone price feeds at once
+ */
+export class RedstoneUpdater extends SDKConstruct {
+  #logger?: ILogger;
+  #cache = new Map<string, TimestampedCalldata>();
+  #historicalTimestampMs?: number;
+  #gateways?: string[];
+
+  constructor(sdk: GearboxSDK) {
+    super(sdk);
+    this.#logger = childLogger("RedstoneUpdater", sdk.logger);
+  }
+
+  /**
+   * Set redstone historical timestamp in milliseconds
+   */
+  public set historicalTimestamp(timestampMs: number) {
+    // redstone timestamps are rounded to one minute
+    this.#historicalTimestampMs = 60_000 * Math.floor(timestampMs / 60_000);
+  }
+
+  /**
+   * Set redstone gateways
+   */
+  public set gateways(gateways: string[]) {
+    this.#gateways = gateways;
+  }
+
+  public async getUpdateTxs(
+    feeds: RedstonePriceFeedContract[],
+    logContext: Record<string, any> = {},
+  ): Promise<UpdatePFTask[]> {
+    this.#logger?.debug(
+      logContext,
+      `generating update transactions for ${feeds.length} redstone price feeds`,
+    );
+
+    // Group feeds by dataServiceId and uniqueSignersCount
+    const groupedFeeds: Record<string, Set<string>> = {};
+    const priceFeeds = new Map<string, RedstonePriceFeedContract>();
+    for (const feed of feeds) {
+      const key = `${feed.dataServiceId}:${feed.signersThreshold}`;
+      if (!groupedFeeds[key]) {
+        groupedFeeds[key] = new Set();
+      }
+      groupedFeeds[key].add(feed.dataId);
+      priceFeeds.set(feed.dataId, feed);
+    }
+
+    const results: UpdatePFTask[] = [];
+    for (const [key, group] of Object.entries(groupedFeeds)) {
+      const [dataServiceId, signersStr] = key.split(":");
+      const uniqueSignersCount = parseInt(signersStr, 10);
+      const payloads = await this.#getPayloads(
+        dataServiceId,
+        group,
+        uniqueSignersCount,
+      );
+
+      for (const { dataFeedId, data, timestamp } of payloads) {
+        const priceFeed = priceFeeds.get(dataFeedId);
+        if (!priceFeed) {
+          throw new Error(`cannot get price feed address for ${dataFeedId}`);
+        }
+        results.push({
+          priceFeed: priceFeed.address.toLowerCase() as Address,
+          tx: priceFeed.createRawTx({
+            functionName: "updatePrice",
+            args: [data as Hex],
+            description: `updating price for ${dataFeedId} [${this.sdk.provider.addressLabels.get(priceFeed.address)}]`,
+          }),
+          timestamp,
+        });
+      }
+    }
+    this.#logger?.debug(
+      logContext,
+      `generated ${results.length} update transactions for redstone price feeds`,
+    );
+    return results;
+  }
+
+  /**
+   * Gets redstone payloads in one request for multiple feeds with the same dataServiceId and uniqueSignersCount
+   * If historicalTimestamp is set, responses will be cached
+   * @param dataServiceId
+   * @param dataFeedsIds
+   * @param uniqueSignersCount
+   * @returns
+   */
+  async #getPayloads(
+    dataServiceId: string,
+    dataFeedsIds: Set<string>,
+    uniqueSignersCount: number,
+  ): Promise<TimestampedCalldata[]> {
+    this.#logger?.debug(
+      `getting redstone payloads for ${dataFeedsIds.size} data feeds in ${dataServiceId} with ${uniqueSignersCount} signers: ${Array.from(dataFeedsIds).join(", ")}`,
+    );
+    const fromCache: TimestampedCalldata[] = [];
+    const uncached: string[] = [];
+    for (const dataFeedId of dataFeedsIds) {
+      const key = cacheKey(
+        dataServiceId,
+        dataFeedId,
+        uniqueSignersCount,
+        this.#historicalTimestampMs,
+      );
+      const cached = this.#cache.get(key);
+      if (this.#historicalTimestampMs && !!cached) {
+        fromCache.push(cached);
+      } else {
+        uncached.push(dataFeedId);
+      }
+    }
+
+    const fromRedstone = await this.#fetchPayloads(
+      dataServiceId,
+      new Set(uncached),
+      uniqueSignersCount,
+    );
+    // cache newly fetched responses
+    if (this.#historicalTimestampMs) {
+      for (const resp of fromRedstone) {
+        const key = cacheKey(
+          dataServiceId,
+          resp.dataFeedId,
+          uniqueSignersCount,
+          this.#historicalTimestampMs,
+        );
+        this.#cache.set(key, resp);
+      }
+    }
+    this.#logger?.debug(
+      `got ${fromRedstone.length} new redstone updates and ${fromCache.length} from cache`,
+    );
+
+    return [...fromCache, ...fromRedstone];
+  }
+
+  /**
+   * Fetches redstone payloads in one request for multiple feeds with the same dataServiceId and uniqueSignersCount
+   * Payloads are loaded in one request to avoid redstone rate limit
+   * @param dataServiceId
+   * @param dataFeedsIds
+   * @param uniqueSignersCount
+   * @returns
+   */
+  async #fetchPayloads(
+    dataServiceId: string,
+    dataFeedsIds: Set<string>,
+    uniqueSignersCount: number,
+  ): Promise<TimestampedCalldata[]> {
+    if (dataFeedsIds.size === 0) {
+      return [];
+    }
+    const dataPackagesIds = Array.from(dataFeedsIds);
+    const tsStr = this.#historicalTimestampMs
+      ? ` with historical timestamp ${this.#historicalTimestampMs}`
+      : "";
+    this.#logger?.debug(
+      `fetching redstone payloads for ${dataFeedsIds.size} data feeds in ${dataServiceId} with ${uniqueSignersCount} signers: ${dataPackagesIds.join(", ")}${tsStr}`,
+    );
+    const wrapper = new DataServiceWrapper({
+      dataServiceId,
+      dataPackagesIds,
+      uniqueSignersCount,
+      historicalTimestamp: this.#historicalTimestampMs,
+      urls: this.#gateways,
+    });
+
+    const dataPayload = await retry(
+      () => wrapper.prepareRedstonePayload(true),
+      { attempts: 5, interval: this.#historicalTimestampMs ? 30_500 : 250 },
+    );
+
+    const parsed = RedstonePayload.parse(toBytes(`0x${dataPayload}`));
+    const packagesByDataFeedId = groupDataPackages(parsed.signedDataPackages);
+
+    return dataPackagesIds.map(dataFeedId => {
+      const signedDataPackages = packagesByDataFeedId[dataFeedId];
+      if (!signedDataPackages) {
+        throw new Error(`cannot find data packages for ${dataFeedId}`);
+      }
+      if (signedDataPackages.length !== uniqueSignersCount) {
+        throw new Error(
+          `got ${signedDataPackages.length} data packages for ${dataFeedId}, but expected ${uniqueSignersCount}`,
+        );
+      }
+      return getCalldataWithTimestamp(
+        dataFeedId,
+        signedDataPackages,
+        wrapper.getUnsignedMetadata(),
+      );
+    });
+  }
+}
+
+function cacheKey(
+  dataServiceId: string,
+  dataFeedId: string,
+  uniqueSignersCount: number,
+  historicalTimestamp = 0,
+): string {
+  return `${dataServiceId}:${dataFeedId}:${uniqueSignersCount}:${historicalTimestamp}`;
+}
+
+/**
+ * Groups SignedDataPackages by dataFeedId
+ * @param signedDataPackages
+ * @returns
+ */
+function groupDataPackages(
+  signedDataPackages: SignedDataPackage[],
+): Record<string, SignedDataPackage[]> {
+  const packagesByDataFeedId: Record<string, SignedDataPackage[]> = {};
+  for (const p of signedDataPackages) {
+    const { dataPoints } = p.dataPackage;
+
+    // Check if all data points have the same dataFeedId
+    const dataFeedId0 = dataPoints[0].dataFeedId;
+    for (const dp of dataPoints) {
+      if (dp.dataFeedId !== dataFeedId0) {
+        throw new Error(
+          `data package contains data points with different dataFeedIds: ${dp.dataFeedId} and ${dataFeedId0}`,
+        );
+      }
+    }
+
+    // Group data packages by dataFeedId
+    if (!packagesByDataFeedId[dataFeedId0]) {
+      packagesByDataFeedId[dataFeedId0] = [];
+    }
+    packagesByDataFeedId[dataFeedId0].push(p);
+  }
+
+  return packagesByDataFeedId;
+}
+
+function getCalldataWithTimestamp(
+  dataFeedId: string,
+  packages: SignedDataPackage[],
+  unsignedMetadata: string,
+): TimestampedCalldata {
+  const originalPayload = RedstonePayload.prepare(packages, unsignedMetadata);
+
+  // Calculating the number of bytes in the hex representation of payload
+  // We divide by 2, beacuse 2 symbols in a hex string represent one byte
+  const originalPayloadLength = originalPayload.length / 2;
+
+  // Number of bytes that we want to add to unsigned metadata so that
+  // payload byte size becomes a multiplicity of 32
+  const bytesToAdd = 32 - (originalPayloadLength % 32);
+
+  // Adding underscores to the end of the metadata string, each underscore
+  // uses one byte in UTF-8
+  const newUnsignedMetadata = unsignedMetadata + "_".repeat(bytesToAdd);
+
+  const payload = RedstonePayload.prepare(packages, newUnsignedMetadata);
+
+  let timestamp = 0;
+  for (const p of packages) {
+    const newTimestamp = p.dataPackage.timestampMilliseconds / 1000;
+    if (timestamp === 0) {
+      timestamp = newTimestamp;
+    } else if (timestamp !== newTimestamp) {
+      throw new Error("Timestamps are not equal");
+    }
+  }
+
+  return {
+    dataFeedId,
+    data: encodeAbiParameters(
+      [{ type: "uint256" }, { type: "bytes" }],
+      [BigInt(timestamp), `0x${payload}`],
+    ),
+    timestamp,
+  };
+}

package/src/sdk/market/pricefeeds/WstETHPriceFeed.ts

@@ -0,0 +1,24 @@
+import { iwstEthAbi, wstEthPriceFeedAbi } from "../../abi";
+import type { GearboxSDK } from "../../GearboxSDK";
+import { AbstractLPPriceFeedContract } from "./AbstractLPPriceFeed";
+import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed";
+
+type abi = typeof wstEthPriceFeedAbi;
+
+export class WstETHPriceFeedContract extends AbstractLPPriceFeedContract<abi> {
+  constructor(sdk: GearboxSDK, args: PartialPriceFeedTreeNode) {
+    super(sdk, {
+      ...args,
+      name: "WstETHPriceFeed",
+      abi: wstEthPriceFeedAbi,
+    });
+  }
+
+  public override async getValue(): Promise<bigint> {
+    return await this.sdk.provider.publicClient.readContract({
+      abi: iwstEthAbi,
+      address: this.lpContract,
+      functionName: "stEthPerToken",
+    });
+  }
+}