@gearbox-protocol/sdk 8.0.4 → 8.1.0-next.1

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,151 @@
+import { decodeAbiParameters, encodeAbiParameters } 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"));
+    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 [datas] = decodeAbiParameters(
+    [{ type: "bytes[]" }],
+    `0x${resp.binary.data}`
+  );
+  return resp.parsed.map((pf, i) => {
+    return {
+      dataFeedId: pf.id,
+      data: encodeAbiParameters(
+        [{ type: "uint256" }, { type: "bytes" }],
+        [BigInt(pf.price.publish_time), datas[i]]
+      ),
+      timestamp: pf.price.publish_time,
+      cached: false
+    };
+  });
+}
+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/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 {

package/dist/types/sdk/abi/oracles.d.ts

@@ -6157,3 +6157,215 @@ export declare const pendleTWAPPTPriceFeedAbi: readonly [{
     readonly name: "StalePriceException";
     readonly inputs: readonly [];
 }];
+export declare const pythPriceFeedAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "_token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "_priceFeedId";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "_pyth";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "_maxConfToPriceRatio";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "descriptionTicker";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "receive";
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "contractType";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "decimals";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "description";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "latestRoundData";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint80";
+        readonly internalType: "uint80";
+    }, {
+        readonly name: "";
+        readonly type: "int256";
+        readonly internalType: "int256";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "uint80";
+        readonly internalType: "uint80";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "maxConfToPriceRatio";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "priceFeedId";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "pyth";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "serialize";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "skipPriceCheck";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "token";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "updatable";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "updatePrice";
+    readonly inputs: readonly [{
+        readonly name: "data";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "version";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "UpdatePrice";
+    readonly inputs: readonly [{
+        readonly name: "price";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "ConfToPriceRatioTooHighException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "IncorrectExpectedPublishTimestampException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "IncorrectParameterException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "IncorrectPriceDecimalsException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "IncorrectPriceException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "PriceTimestampTooFarAheadException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "PriceTimestampTooFarBehindException";
+    readonly inputs: readonly [];
+}];

package/dist/types/sdk/market/pricefeeds/AbstractPriceFeed.d.ts

@@ -4,7 +4,7 @@ import { BaseContract } from "../../base/index.js";
 import type { GearboxSDK } from "../../GearboxSDK.js";
 import type { PriceFeedStateHuman } from "../../types/index.js";
 import { PriceFeedRef } from "./PriceFeedRef.js";
-import type { IPriceFeedContract, PriceFeedContractType } from "./types.js";
+import type { IPriceFeedContract, IUpdatablePriceFeedContract, PriceFeedContractType } from "./types.js";
 export type PartialPriceFeedTreeNode = RequiredBy<Partial<PriceFeedTreeNode>, "baseParams">;
 export type PriceFeedConstructorArgs<abi extends Abi | readonly unknown[]> = PartialPriceFeedTreeNode & {
     abi: abi;
@@ -30,5 +30,5 @@ export declare abstract class AbstractPriceFeedContract<const abi extends Abi |
     answer(overrides?: {
         blockNumber?: bigint;
     }): Promise<bigint>;
-    updatableDependencies(): IPriceFeedContract[];
+    updatableDependencies(): IUpdatablePriceFeedContract[];
 }