@gearbox-protocol/sdk 8.1.5 → 8.2.0-next.1

package/dist/esm/sdk/market/pricefeeds/PriceFeedsRegister.js

@@ -22,8 +22,8 @@ import { ExternalPriceFeedContract } from "./ExternalPriceFeed.js";
 import { MellowLRTPriceFeedContract } from "./MellowLRTPriceFeed.js";
 import { PendleTWAPPTPriceFeed } from "./PendleTWAPPTPriceFeed.js";
 import { PythPriceFeed } from "./PythPriceFeed.js";
-import { isRedstone, RedstonePriceFeedContract } from "./RedstonePriceFeed.js";
-import { RedstoneUpdater } from "./RedstoneUpdater.js";
+import { RedstonePriceFeedContract } from "./RedstonePriceFeed.js";
+import { PythUpdater, RedstoneUpdater } from "./updates/index.js";
 import { WstETHPriceFeedContract } from "./WstETHPriceFeed.js";
 import { YearnPriceFeedContract } from "./YearnPriceFeed.js";
 import { ZeroPriceFeedContract } from "./ZeroPriceFeed.js";
@@ -32,11 +32,14 @@ class PriceFeedRegister extends SDKConstruct {
   #hooks = new Hooks();
   #feeds = new AddressMap(void 0, "priceFeeds");
   #latestUpdate;
-  redstoneUpdater;
+  updaters;
   constructor(sdk, opts = {}) {
     super(sdk);
     this.logger = childLogger("PriceFeedRegister", sdk.logger);
-    this.redstoneUpdater = new RedstoneUpdater(sdk, opts?.redstone);
+    this.updaters = [
+      new RedstoneUpdater(sdk, opts?.redstone),
+      new PythUpdater(sdk, opts?.pyth)
+    ];
   }
   addHook = this.#hooks.addHook.bind(this.#hooks);
   removeHook = this.#hooks.removeHook.bind(this.#hooks);
@@ -49,31 +52,22 @@ class PriceFeedRegister extends SDKConstruct {
   async generatePriceFeedsUpdateTxs(priceFeeds, logContext = {}) {
     const updateables = priceFeeds ? priceFeeds.flatMap((pf) => pf.updatableDependencies()) : this.#feeds.values();
     const txs = [];
-    const redstonePFs = [];
     const latestUpdate = {
-      redstone: [],
+      updates: [],
       timestamp: Math.floor(Date.now() / 1e3)
     };
-    for (const pf of updateables) {
-      if (isRedstone(pf)) {
-        redstonePFs.push(pf);
-      }
-    }
+    const updates = (await Promise.all(
+      this.updaters.map((u) => u.getUpdateTxs(updateables, logContext))
+    )).flat();
     let maxTimestamp = 0;
-    if (redstonePFs.length > 0) {
-      const redstoneUpdates = await this.redstoneUpdater.getUpdateTxs(
-        redstonePFs,
-        logContext
-      );
-      for (const tx of redstoneUpdates) {
-        const { data } = tx;
-        const { timestamp } = data;
-        if (timestamp > maxTimestamp) {
-          maxTimestamp = timestamp;
-        }
-        txs.push(tx);
-        latestUpdate.redstone.push(data);
+    for (const tx of updates) {
+      const { data } = tx;
+      const { timestamp } = data;
+      if (timestamp > maxTimestamp) {
+        maxTimestamp = timestamp;
       }
+      txs.push(tx);
+      latestUpdate.updates.push(data);
     }
     const result = { txs, timestamp: maxTimestamp };
     const tsDelta = BigInt(maxTimestamp) - this.sdk.timestamp;

package/dist/esm/sdk/market/pricefeeds/PythPriceFeed.js

@@ -1,6 +1,7 @@
 import { decodeAbiParameters } from "viem";
+import { pythPriceFeedAbi } from "../../abi/oracles.js";
 import { AbstractPriceFeedContract } from "./AbstractPriceFeed.js";
-const abi = [];
+const abi = pythPriceFeedAbi;
 class PythPriceFeed extends AbstractPriceFeedContract {
   token;
   priceFeedId;
@@ -40,6 +41,13 @@ class PythPriceFeed extends AbstractPriceFeedContract {
       this.pyth = decoded[2];
     }
   }
+  createPriceUpdateTx(data) {
+    return this.createRawTx({
+      functionName: "updatePrice",
+      args: [data],
+      description: `updating pyth price for ${this.priceFeedId} [${this.labelAddress(this.address)}]`
+    });
+  }
 }
 export {
   PythPriceFeed

package/dist/esm/sdk/market/pricefeeds/RedstonePriceFeed.js

@@ -75,11 +75,14 @@ class RedstonePriceFeedContract extends AbstractPriceFeedContract {
       lastPayloadTimestamp: this.lastPayloadTimestamp.toString()
     };
   }
-}
-function isRedstone(pf) {
-  return pf.contractType === "PRICE_FEED::REDSTONE";
+  createPriceUpdateTx(data) {
+    return this.createRawTx({
+      functionName: "updatePrice",
+      args: [data],
+      description: `updating redstone price for ${this.dataId} [${this.labelAddress(this.address)}]`
+    });
+  }
 }
 export {
-  RedstonePriceFeedContract,
-  isRedstone
+  RedstonePriceFeedContract
 };

package/dist/esm/sdk/market/pricefeeds/index.js

@@ -8,6 +8,7 @@ export * from "./CurveStablePriceFeed.js";
 export * from "./CurveUSDPriceFeed.js";
 export * from "./Erc4626PriceFeed.js";
 export * from "./ExternalPriceFeed.js";
+export * from "./isUpdatablePriceFeed.js";
 export * from "./MellowLRTPriceFeed.js";
 export * from "./PendleTWAPPTPriceFeed.js";
 export * from "./PriceFeedRef.js";

package/dist/esm/sdk/market/pricefeeds/isUpdatablePriceFeed.js

@@ -0,0 +1,6 @@
+function isUpdatablePriceFeed(pf) {
+  return pf.updatable;
+}
+export {
+  isUpdatablePriceFeed
+};

package/dist/esm/sdk/market/pricefeeds/updates/PriceUpdateTx.js

@@ -0,0 +1,28 @@
+const MAX_DATA_TIMESTAMP_DELAY_SECONDS = 10n * 60n;
+const MAX_DATA_TIMESTAMP_AHEAD_SECONDS = 60n;
+class PriceUpdateTx {
+  raw;
+  data;
+  constructor(raw, data) {
+    this.raw = raw;
+    this.data = data;
+  }
+  get pretty() {
+    const cached = this.data.cached ? " (cached)" : "";
+    return `${this.name} feed ${this.data.dataFeedId} at ${this.data.priceFeed} with timestamp ${this.data.timestamp}${cached}`;
+  }
+  validateTimestamp(blockTimestamp) {
+    const { timestamp: expectedPayloadTimestamp } = this.data;
+    if (blockTimestamp < expectedPayloadTimestamp) {
+      if (BigInt(expectedPayloadTimestamp) - blockTimestamp > MAX_DATA_TIMESTAMP_AHEAD_SECONDS) {
+        return "in future";
+      }
+    } else if (blockTimestamp - BigInt(expectedPayloadTimestamp) > MAX_DATA_TIMESTAMP_DELAY_SECONDS) {
+      return "too old";
+    }
+    return "valid";
+  }
+}
+export {
+  PriceUpdateTx
+};

package/dist/esm/sdk/market/pricefeeds/{RedstoneCache.js → updates/PriceUpdatesCache.js}

@@ -1,4 +1,4 @@
-class RedstoneCache {
+class PriceUpdatesCache {
   #cache = /* @__PURE__ */ new Map();
   #ttlMs;
   #historical;
@@ -6,8 +6,8 @@ class RedstoneCache {
     this.#ttlMs = opts.ttl;
     this.#historical = opts.historical;
   }
-  get(dataServiceId, dataFeedId, uniqueSignersCount) {
-    const key = this.#cacheKey(dataServiceId, dataFeedId, uniqueSignersCount);
+  get(...path) {
+    const key = this.#cacheKey(...path);
     const data = this.#cache.get(key);
     if (!data) {
       return void 0;
@@ -18,8 +18,8 @@ class RedstoneCache {
     }
     return data;
   }
-  set(dataServiceId, dataFeedId, uniqueSignersCount, value) {
-    const key = this.#cacheKey(dataServiceId, dataFeedId, uniqueSignersCount);
+  set(value, ...path) {
+    const key = this.#cacheKey(...path);
     this.#cache.set(key, value);
   }
   #expired(value) {
@@ -28,10 +28,10 @@ class RedstoneCache {
     }
     return value.timestamp * 1e3 + this.#ttlMs < Date.now();
   }
-  #cacheKey(dataServiceId, dataFeedId, uniqueSignersCount) {
-    return `${dataServiceId}:${dataFeedId}:${uniqueSignersCount}`;
+  #cacheKey(...path) {
+    return path.join(":");
   }
 }
 export {
-  RedstoneCache
+  PriceUpdatesCache
 };

package/dist/esm/sdk/market/pricefeeds/updates/PythUpdater.js

@@ -0,0 +1,169 @@
+import {
+  parseAccumulatorUpdateData,
+  parsePriceFeedMessage,
+  sliceAccumulatorUpdateData
+} from "@pythnetwork/price-service-sdk";
+import { encodeAbiParameters, toHex } from "viem";
+import { SDKConstruct } from "../../../base/index.js";
+import { childLogger, retry } from "../../../utils/index.js";
+import { PriceUpdatesCache } from "./PriceUpdatesCache.js";
+import { PriceUpdateTx } from "./PriceUpdateTx.js";
+class PythUpdateTx extends PriceUpdateTx {
+  name = "pyth";
+}
+class PythUpdater extends SDKConstruct {
+  #logger;
+  #cache;
+  #historicalTimestamp;
+  #api;
+  #ignoreMissingFeeds;
+  constructor(sdk, opts = {}) {
+    super(sdk);
+    this.#logger = childLogger("PythUpdater", sdk.logger);
+    this.#ignoreMissingFeeds = opts.ignoreMissingFeeds;
+    this.#api = opts.apiProxy ?? "https://hermes.pyth.network/v2/updates/price/";
+    this.#api = this.#api.endsWith("/") ? this.#api : this.#api + "/";
+    let ts = opts.historicTimestamp;
+    if (ts) {
+      this.#historicalTimestamp = ts === true ? Number(this.sdk.timestamp) : ts;
+    }
+    this.#cache = new PriceUpdatesCache({
+      // currently staleness period is 240 seconds on all networks, add some buffer
+      // this period of 4 minutes is selected based on time that is required for user to sign transaction with wallet
+      // so it's unlikely to decrease
+      ttl: opts.cacheTTL ?? 225 * 1e3,
+      historical: !!ts
+    });
+  }
+  async getUpdateTxs(feeds, logContext = {}) {
+    this.#logger?.debug(
+      logContext,
+      `generating update transactions for ${feeds.length} pyth price feeds`
+    );
+    const pythFeeds = new Map(
+      feeds.filter(isPyth).map((f) => [f.priceFeedId, f])
+    );
+    const payloads = await this.#getPayloads(new Set(pythFeeds.keys()));
+    const results = payloads.map((p) => {
+      const priceFeed = pythFeeds.get(p.dataFeedId);
+      if (!priceFeed) {
+        throw new Error(`cannot find price feed for ${p.dataFeedId}`);
+      }
+      const { dataFeedId, timestamp, cached, data } = p;
+      return new PythUpdateTx(priceFeed.createPriceUpdateTx(data), {
+        dataFeedId,
+        priceFeed: priceFeed.address,
+        timestamp,
+        cached
+      });
+    });
+    this.#logger?.debug(
+      logContext,
+      `generated ${results.length} update transactions for pyth price feeds`
+    );
+    return results;
+  }
+  /**
+   * Gets pyth payloads
+   * @param dataFeedsIds
+   * @returns
+   */
+  async #getPayloads(dataFeedsIds) {
+    this.#logger?.debug(
+      `getting pyth payloads for ${dataFeedsIds.size} price feeds: ${Array.from(dataFeedsIds).join(", ")}`
+    );
+    const fromCache = [];
+    const uncached = [];
+    for (const priceFeedsId of dataFeedsIds) {
+      const cached = this.#cache.get(priceFeedsId);
+      if (cached) {
+        fromCache.push({ ...cached, cached: true });
+      } else {
+        uncached.push(priceFeedsId);
+      }
+    }
+    const fromPyth = await this.#fetchPayloads(
+      new Set(uncached)
+    );
+    for (const resp of fromPyth) {
+      this.#cache.set(resp, resp.dataFeedId);
+    }
+    this.#logger?.debug(
+      `got ${fromPyth.length} new pyth updates and ${fromCache.length} from cache`
+    );
+    return [...fromCache, ...fromPyth];
+  }
+  /**
+   * Fetches pyth payloads from Hermes API
+   * @param dataFeedsIds
+   * @returns
+   */
+  async #fetchPayloads(dataFeedsIds) {
+    if (dataFeedsIds.size === 0) {
+      return [];
+    }
+    const ids = Array.from(dataFeedsIds);
+    const tsStr = this.#historicalTimestamp ? ` with historical timestamp ${this.#historicalTimestamp}` : "";
+    this.#logger?.debug(
+      `fetching pyth payloads for ${dataFeedsIds.size} price feeds: ${ids.join(", ")}${tsStr}`
+    );
+    const url = new URL(this.#api + (this.#historicalTimestamp ?? "latest"));
+    url.searchParams.append("parsed", "false");
+    if (this.#ignoreMissingFeeds) {
+      url.searchParams.append("ignore_invalid_price_ids", "true");
+    }
+    for (const id of dataFeedsIds) {
+      url.searchParams.append("ids[]", id);
+    }
+    const resp = await retry(
+      async () => {
+        const resp2 = await fetch(url.toString());
+        if (!resp2.ok) {
+          const body = await resp2.text();
+          throw new Error(
+            `failed to fetch pyth payloads: ${resp2.statusText}: ${body}`
+          );
+        }
+        const data = await resp2.json();
+        return data;
+      },
+      { attempts: 3, exponent: 2, interval: 200 }
+    );
+    return respToCalldata(resp);
+  }
+}
+function isPyth(pf) {
+  return pf.contractType === "PRICE_FEED::PYTH";
+}
+function respToCalldata(resp) {
+  const updates = splitAccumulatorUpdates(resp.binary.data[0]);
+  return updates.map(({ data, dataFeedId, timestamp }) => {
+    return {
+      dataFeedId,
+      data: encodeAbiParameters(
+        [{ type: "uint256" }, { type: "bytes[]" }],
+        [BigInt(timestamp), [data]]
+      ),
+      timestamp,
+      cached: false
+    };
+  });
+}
+function splitAccumulatorUpdates(binary) {
+  const data = Buffer.from(binary, "hex");
+  const parsed = parseAccumulatorUpdateData(data);
+  const results = [];
+  for (let i = 0; i < parsed.updates.length; i++) {
+    const upd = parsed.updates[i].message;
+    const msg = parsePriceFeedMessage(upd);
+    results.push({
+      dataFeedId: toHex(msg.feedId),
+      timestamp: msg.publishTime.toNumber(),
+      data: toHex(sliceAccumulatorUpdateData(data, i, i + 1))
+    });
+  }
+  return results;
+}
+export {
+  PythUpdater
+};

package/dist/esm/sdk/market/pricefeeds/{RedstoneUpdater.js → updates/RedstoneUpdater.js}

@@ -1,33 +1,12 @@
 import { DataServiceWrapper } from "@redstone-finance/evm-connector";
 import { RedstonePayload } from "@redstone-finance/protocol";
 import { encodeAbiParameters, toBytes } from "viem";
-import { SDKConstruct } from "../../base/index.js";
-import { AddressMap, childLogger, retry } from "../../utils/index.js";
-import { RedstoneCache } from "./RedstoneCache.js";
-const MAX_DATA_TIMESTAMP_DELAY_SECONDS = 10n * 60n;
-const MAX_DATA_TIMESTAMP_AHEAD_SECONDS = 60n;
-class RedstoneUpdateTx {
-  raw;
-  data;
-  constructor(raw, data) {
-    this.raw = raw;
-    this.data = data;
-  }
-  get pretty() {
-    const cached = this.data.cached ? " (cached)" : "";
-    return `redstone feed ${this.data.dataFeedId} at ${this.data.priceFeed} with timestamp ${this.data.timestamp}${cached}`;
-  }
-  validateTimestamp(blockTimestamp) {
-    const { timestamp: expectedPayloadTimestamp } = this.data;
-    if (blockTimestamp < expectedPayloadTimestamp) {
-      if (BigInt(expectedPayloadTimestamp) - blockTimestamp > MAX_DATA_TIMESTAMP_AHEAD_SECONDS) {
-        return "in future";
-      }
-    } else if (blockTimestamp - BigInt(expectedPayloadTimestamp) > MAX_DATA_TIMESTAMP_DELAY_SECONDS) {
-      return "too old";
-    }
-    return "valid";
-  }
+import { SDKConstruct } from "../../../base/index.js";
+import { AddressMap, childLogger, retry } from "../../../utils/index.js";
+import { PriceUpdatesCache } from "./PriceUpdatesCache.js";
+import { PriceUpdateTx } from "./PriceUpdateTx.js";
+class RedstoneUpdateTx extends PriceUpdateTx {
+  name = "redstone";
 }
 class RedstoneUpdater extends SDKConstruct {
   #logger;
@@ -47,7 +26,7 @@ class RedstoneUpdater extends SDKConstruct {
       ts = ts === true ? Number(this.sdk.timestamp) * 1e3 : ts;
       this.#historicalTimestampMs = 6e4 * Math.floor(ts / 6e4);
     }
-    this.#cache = new RedstoneCache({
+    this.#cache = new PriceUpdatesCache({
       // currently staleness period is 240 seconds on all networks, add some buffer
       // this period of 4 minutes is selected based on time that is required for user to sign transaction with wallet
       // so it's unlikely to decrease
@@ -63,6 +42,9 @@ class RedstoneUpdater extends SDKConstruct {
     const groupedFeeds = {};
     const priceFeeds = /* @__PURE__ */ new Map();
     for (const feed of feeds) {
+      if (!isRedstone(feed)) {
+        continue;
+      }
       const key = `${feed.dataServiceId}:${feed.signersThreshold}`;
       if (!groupedFeeds[key]) {
         groupedFeeds[key] = /* @__PURE__ */ new Set();
@@ -88,20 +70,13 @@ class RedstoneUpdater extends SDKConstruct {
         }
         for (const priceFeed of pfsForDataId.values()) {
           results.push(
-            new RedstoneUpdateTx(
-              priceFeed.createRawTx({
-                functionName: "updatePrice",
-                args: [data],
-                description: `updating price for ${dataFeedId} [${this.labelAddress(priceFeed.address)}]`
-              }),
-              {
-                dataFeedId,
-                dataServiceId,
-                priceFeed: priceFeed.address,
-                timestamp,
-                cached
-              }
-            )
+            new RedstoneUpdateTx(priceFeed.createPriceUpdateTx(data), {
+              dataFeedId,
+              dataServiceId,
+              priceFeed: priceFeed.address,
+              timestamp,
+              cached
+            })
           );
         }
       }
@@ -144,7 +119,7 @@ class RedstoneUpdater extends SDKConstruct {
       uniqueSignersCount
     );
     for (const resp of fromRedstone) {
-      this.#cache.set(dataServiceId, resp.dataFeedId, uniqueSignersCount, resp);
+      this.#cache.set(resp, dataServiceId, resp.dataFeedId, uniqueSignersCount);
     }
     this.#logger?.debug(
       `got ${fromRedstone.length} new redstone updates and ${fromCache.length} from cache`
@@ -245,7 +220,9 @@ function getCalldataWithTimestamp(dataFeedId, packages, unsignedMetadata) {
     cached: false
   };
 }
+function isRedstone(pf) {
+  return pf.contractType === "PRICE_FEED::REDSTONE";
+}
 export {
-  RedstoneUpdateTx,
   RedstoneUpdater
 };

package/dist/esm/sdk/market/pricefeeds/updates/index.js

@@ -0,0 +1,6 @@
+import { PythUpdater } from "./PythUpdater.js";
+import { RedstoneUpdater } from "./RedstoneUpdater.js";
+export {
+  PythUpdater,
+  RedstoneUpdater
+};

package/dist/esm/sdk/utils/retry.js

@@ -1,5 +1,6 @@
 async function retry(fn, options = {}) {
-  const { attempts = 3, interval = 200 } = options;
+  const { attempts = 3, interval = 200, exponent = 1 } = options;
+  let wait = interval;
   let cause;
   for (let i = 0; i < attempts; i++) {
     try {
@@ -8,8 +9,9 @@ async function retry(fn, options = {}) {
     } catch (e) {
       cause = e;
       await new Promise((resolve) => {
-        setTimeout(resolve, interval);
+        setTimeout(resolve, wait);
       });
+      wait = wait * exponent;
     }
   }
   throw new Error(`all attempts failed: ${cause}`);

package/dist/esm/sdk/utils/viem/cast.js

@@ -1,6 +1,9 @@
-function generateCastTraceCall(params) {
+function generateCastTraceCall(params, rpcUrl) {
   const { to, data, blockNumber, gas, gasPrice, maxPriorityFeePerGas, value } = params;
-  const cmd = ["cast", "call", "--trace", "--rpc-url", "$RPC_URL"];
+  const cmd = ["cast", "call", "--trace"];
+  if (rpcUrl) {
+    cmd.push("--rpc-url", rpcUrl);
+  }
   if (blockNumber) {
     cmd.push("--block", blockNumber.toString());
   }

package/dist/esm/sdk/utils/viem/simulateMulticall.js

@@ -17,6 +17,7 @@ async function simulateMulticall(client, parameters) {
     blockNumber,
     blockTag,
     gas,
+    value,
     multicallAddress: multicallAddress_
   } = parameters;
   const contracts = parameters.contracts;
@@ -74,7 +75,8 @@ async function simulateMulticall(client, parameters) {
     blockTag,
     // does not infer well that either blockNumber or blockTag must be present
     gas,
-    account
+    account,
+    value
   };
   const results = [];
   const { data } = await getAction(client, call, "call")(request);

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

@@ -201,8 +201,8 @@ class SimulateWithPriceUpdatesError extends BaseError {
     this.timestamp = timestamp;
     this.#request = request;
   }
-  getCastTraceCall() {
-    return this.#request ? generateCastTraceCall(this.#request) : "";
+  getCastTraceCall(rpcUrl) {
+    return this.#request ? generateCastTraceCall(this.#request, rpcUrl) : "";
   }
 }
 export {

package/dist/types/sdk/GearboxSDK.d.ts

@@ -8,7 +8,7 @@ import type { IAddressProviderContract } from "./core/index.js";
 import { BotListContract, GearStakingContract } from "./core/index.js";
 import { MarketRegister } from "./market/MarketRegister.js";
 import { PriceFeedRegister } from "./market/pricefeeds/index.js";
-import type { RedstoneOptions } from "./market/pricefeeds/RedstoneUpdater.js";
+import type { PythOptions, RedstoneOptions } from "./market/pricefeeds/updates/index.js";
 import { type PluginsMap } from "./plugins/index.js";
 import { type IRouterContract } from "./router/index.js";
 import type { GearboxState, GearboxStateHuman, ILogger, MultiCall } from "./types/index.js";
@@ -51,6 +51,10 @@ export interface SDKOptions<Plugins extends PluginsMap> {
      * Options related to redstone price feeds
      */
     redstone?: RedstoneOptions;
+    /**
+     * Options related to pyth price feeds
+     */
+    pyth?: PythOptions;
 }
 export type HydrateOptions<Plugins extends PluginsMap> = Omit<SDKOptions<Plugins>, "blockNumber" | "addressProvider" | "marketConfigurators">;
 export interface SyncStateOptions {