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

package/dist/esm/sdk/abi/oracles.js

@@ -4497,6 +4497,145 @@ const pendleTWAPPTPriceFeedAbi = [
     inputs: []
   }
 ];
+const pythPriceFeedAbi = [
+  {
+    type: "constructor",
+    inputs: [
+      { name: "_token", type: "address", internalType: "address" },
+      { name: "_priceFeedId", type: "bytes32", internalType: "bytes32" },
+      { name: "_pyth", type: "address", internalType: "address" },
+      {
+        name: "_maxConfToPriceRatio",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      { name: "descriptionTicker", type: "string", internalType: "string" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  { type: "receive", stateMutability: "payable" },
+  {
+    type: "function",
+    name: "contractType",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8", internalType: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "description",
+    inputs: [],
+    outputs: [{ name: "", type: "string", internalType: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "latestRoundData",
+    inputs: [],
+    outputs: [
+      { name: "", type: "uint80", internalType: "uint80" },
+      { name: "", type: "int256", internalType: "int256" },
+      { name: "", type: "uint256", internalType: "uint256" },
+      { name: "", type: "uint256", internalType: "uint256" },
+      { name: "", type: "uint80", internalType: "uint80" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "maxConfToPriceRatio",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "priceFeedId",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pyth",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "serialize",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes", internalType: "bytes" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "skipPriceCheck",
+    inputs: [],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "token",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "updatable",
+    inputs: [],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "updatePrice",
+    inputs: [{ name: "data", type: "bytes", internalType: "bytes" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "version",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "UpdatePrice",
+    inputs: [
+      {
+        name: "price",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  { type: "error", name: "ConfToPriceRatioTooHighException", inputs: [] },
+  {
+    type: "error",
+    name: "IncorrectExpectedPublishTimestampException",
+    inputs: []
+  },
+  { type: "error", name: "IncorrectParameterException", inputs: [] },
+  { type: "error", name: "IncorrectPriceDecimalsException", inputs: [] },
+  { type: "error", name: "IncorrectPriceException", inputs: [] },
+  { type: "error", name: "PriceTimestampTooFarAheadException", inputs: [] },
+  { type: "error", name: "PriceTimestampTooFarBehindException", inputs: [] }
+];
 export {
   boundedPriceFeedAbi,
   bptStablePriceFeedAbi,
@@ -4518,6 +4657,7 @@ export {
   iyVaultAbi,
   mellowLrtPriceFeedAbi,
   pendleTWAPPTPriceFeedAbi,
+  pythPriceFeedAbi,
   redstonePriceFeedAbi,
   wstEthPriceFeedAbi,
   yearnPriceFeedAbi,

package/dist/esm/sdk/chain/chains.js

@@ -48,11 +48,11 @@ const chains = {
       network: "Mainnet",
       defaultMarketConfigurators: {
         "0x354fe9f450F60b8547f88BE042E4A45b46128a06": "Chaos Labs",
-        "0x4d427D418342d8CE89a7634c3a402851978B680A": "K3",
-        "0xc168343c791d56dd1da4b4b8b0cc1c1ec1a16e6b": "cp0x",
-        "0x3b56538833fc02f4f0e75609390f26ded0c32e42": "Re7"
+        "0x4d427D418342d8CE89a7634c3a402851978B680A": "K3"
+      },
+      testMarketConfigurators: {
+        "0xc168343c791d56dd1da4b4b8b0cc1c1ec1a16e6b": "cp0x"
       },
-      testMarketConfigurators: {},
       isPublic: true,
       wellKnownToken: {
         address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",

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

@@ -1,5 +1,6 @@
 import { ilpPriceFeedAbi } from "../../abi/index.js";
 import { BaseContract } from "../../base/index.js";
+import { isUpdatablePriceFeed } from "./isUpdatablePriceFeed.js";
 import { PriceFeedRef } from "./PriceFeedRef.js";
 class PartialPriceFeedInitError extends Error {
   priceFeed;
@@ -104,7 +105,7 @@ class AbstractPriceFeedContract extends BaseContract {
     const underlying = this.underlyingPriceFeeds.flatMap(
       (f) => f.priceFeed.updatableDependencies()
     );
-    return this.updatable ? [this, ...underlying] : underlying;
+    return isUpdatablePriceFeed(this) ? [this, ...underlying] : underlying;
   }
 }
 export {

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
+};