@gearbox-protocol/sdk 16.0.0-next.2 → 16.0.0-next.21

package/dist/cjs/onchain/market/pricefeeds/index.js

@@ -0,0 +1,51 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_market_pricefeeds_isUpdatablePriceFeed = require("./isUpdatablePriceFeed.js");
+const require_onchain_market_pricefeeds_PriceFeedRef = require("./PriceFeedRef.js");
+const require_onchain_market_pricefeeds_AbstractPriceFeed = require("./AbstractPriceFeed.js");
+const require_onchain_market_pricefeeds_AbstractLPPriceFeed = require("./AbstractLPPriceFeed.js");
+const require_onchain_market_pricefeeds_BalancerStablePriceFeed = require("./BalancerStablePriceFeed.js");
+const require_onchain_market_pricefeeds_BalancerWeightedPriceFeed = require("./BalancerWeightedPriceFeed.js");
+const require_onchain_market_pricefeeds_BoundedPriceFeed = require("./BoundedPriceFeed.js");
+const require_onchain_market_pricefeeds_CompositePriceFeed = require("./CompositePriceFeed.js");
+const require_onchain_market_pricefeeds_CurveCryptoPriceFeed = require("./CurveCryptoPriceFeed.js");
+const require_onchain_market_pricefeeds_CurveStablePriceFeed = require("./CurveStablePriceFeed.js");
+const require_onchain_market_pricefeeds_CurveUSDPriceFeed = require("./CurveUSDPriceFeed.js");
+const require_onchain_market_pricefeeds_Erc4626PriceFeed = require("./Erc4626PriceFeed.js");
+const require_onchain_market_pricefeeds_ExternalPriceFeed = require("./ExternalPriceFeed.js");
+const require_onchain_market_pricefeeds_getRawPriceUpdates = require("./getRawPriceUpdates.js");
+const require_onchain_market_pricefeeds_MellowLRTPriceFeed = require("./MellowLRTPriceFeed.js");
+const require_onchain_market_pricefeeds_PendleTWAPPTPriceFeed = require("./PendleTWAPPTPriceFeed.js");
+const require_onchain_market_pricefeeds_PythPriceFeed = require("./PythPriceFeed.js");
+const require_onchain_market_pricefeeds_RedstonePriceFeed = require("./RedstonePriceFeed.js");
+const require_onchain_market_pricefeeds_updates_fetchRedstonePayloads = require("./updates/fetchRedstonePayloads.js");
+require("./updates/index.js");
+const require_onchain_market_pricefeeds_WstETHPriceFeed = require("./WstETHPriceFeed.js");
+const require_onchain_market_pricefeeds_YearnPriceFeed = require("./YearnPriceFeed.js");
+const require_onchain_market_pricefeeds_ZeroPriceFeed = require("./ZeroPriceFeed.js");
+const require_onchain_market_pricefeeds_PriceFeedsRegister = require("./PriceFeedsRegister.js");
+require("./types.js");
+exports.AbstractLPPriceFeedContract = require_onchain_market_pricefeeds_AbstractLPPriceFeed.AbstractLPPriceFeedContract;
+exports.AbstractPriceFeedContract = require_onchain_market_pricefeeds_AbstractPriceFeed.AbstractPriceFeedContract;
+exports.BalancerStablePriceFeedContract = require_onchain_market_pricefeeds_BalancerStablePriceFeed.BalancerStablePriceFeedContract;
+exports.BalancerWeightedPriceFeedContract = require_onchain_market_pricefeeds_BalancerWeightedPriceFeed.BalancerWeightedPriceFeedContract;
+exports.BoundedPriceFeedContract = require_onchain_market_pricefeeds_BoundedPriceFeed.BoundedPriceFeedContract;
+exports.CompositePriceFeedContract = require_onchain_market_pricefeeds_CompositePriceFeed.CompositePriceFeedContract;
+exports.CurveCryptoPriceFeedContract = require_onchain_market_pricefeeds_CurveCryptoPriceFeed.CurveCryptoPriceFeedContract;
+exports.CurveStablePriceFeedContract = require_onchain_market_pricefeeds_CurveStablePriceFeed.CurveStablePriceFeedContract;
+exports.CurveUSDPriceFeedContract = require_onchain_market_pricefeeds_CurveUSDPriceFeed.CurveUSDPriceFeedContract;
+exports.Erc4626PriceFeedContract = require_onchain_market_pricefeeds_Erc4626PriceFeed.Erc4626PriceFeedContract;
+exports.ExternalPriceFeedContract = require_onchain_market_pricefeeds_ExternalPriceFeed.ExternalPriceFeedContract;
+exports.MellowLRTPriceFeedContract = require_onchain_market_pricefeeds_MellowLRTPriceFeed.MellowLRTPriceFeedContract;
+exports.PartialPriceFeedInitError = require_onchain_market_pricefeeds_AbstractPriceFeed.PartialPriceFeedInitError;
+exports.PendleTWAPPTPriceFeed = require_onchain_market_pricefeeds_PendleTWAPPTPriceFeed.PendleTWAPPTPriceFeed;
+exports.PriceFeedRef = require_onchain_market_pricefeeds_PriceFeedRef.PriceFeedRef;
+exports.PriceFeedRegister = require_onchain_market_pricefeeds_PriceFeedsRegister.PriceFeedRegister;
+exports.PythPriceFeed = require_onchain_market_pricefeeds_PythPriceFeed.PythPriceFeed;
+exports.RedstonePriceFeedContract = require_onchain_market_pricefeeds_RedstonePriceFeed.RedstonePriceFeedContract;
+exports.WstETHPriceFeedContract = require_onchain_market_pricefeeds_WstETHPriceFeed.WstETHPriceFeedContract;
+exports.YearnPriceFeedContract = require_onchain_market_pricefeeds_YearnPriceFeed.YearnPriceFeedContract;
+exports.ZeroPriceFeedContract = require_onchain_market_pricefeeds_ZeroPriceFeed.ZeroPriceFeedContract;
+exports.fetchRedstonePayloads = require_onchain_market_pricefeeds_updates_fetchRedstonePayloads.fetchRedstonePayloads;
+exports.getRawPriceUpdates = require_onchain_market_pricefeeds_getRawPriceUpdates.getRawPriceUpdates;
+exports.isLPPriceFeed = require_onchain_market_pricefeeds_AbstractLPPriceFeed.isLPPriceFeed;
+exports.isUpdatablePriceFeed = require_onchain_market_pricefeeds_isUpdatablePriceFeed.isUpdatablePriceFeed;

package/dist/cjs/onchain/market/pricefeeds/isUpdatablePriceFeed.js

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/onchain/market/pricefeeds/isUpdatablePriceFeed.ts
+function isUpdatablePriceFeed(pf) {
+	return pf.updatable;
+}
+//#endregion
+exports.isUpdatablePriceFeed = isUpdatablePriceFeed;

package/dist/cjs/onchain/market/pricefeeds/updates/PriceUpdateTx.js

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/onchain/market/pricefeeds/updates/PriceUpdateTx.ts
+const MAX_DATA_TIMESTAMP_DELAY_SECONDS = 10n * 60n;
+const MAX_DATA_TIMESTAMP_AHEAD_SECONDS = 60n;
+var PriceUpdateTx = class {
+	/**
+	* raw tx with encoded `priceFeed.updatePrice` call
+	*/
+	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";
+	}
+};
+//#endregion
+exports.PriceUpdateTx = PriceUpdateTx;

package/dist/cjs/onchain/market/pricefeeds/updates/PriceUpdatesCache.js

@@ -0,0 +1,34 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/onchain/market/pricefeeds/updates/PriceUpdatesCache.ts
+var PriceUpdatesCache = class {
+	#cache = /* @__PURE__ */ new Map();
+	#ttlMs;
+	#historical;
+	constructor(opts) {
+		this.#ttlMs = opts.ttl;
+		this.#historical = opts.historical;
+	}
+	get(...path) {
+		const key = this.#cacheKey(...path);
+		const data = this.#cache.get(key);
+		if (!data) return;
+		if (this.#expired(data)) {
+			this.#cache.delete(key);
+			return;
+		}
+		return data;
+	}
+	set(value, ...path) {
+		const key = this.#cacheKey(...path);
+		this.#cache.set(key, value);
+	}
+	#expired(value) {
+		if (this.#historical) return false;
+		return value.timestamp * 1e3 + this.#ttlMs < Date.now();
+	}
+	#cacheKey(...path) {
+		return path.join(":");
+	}
+};
+//#endregion
+exports.PriceUpdatesCache = PriceUpdatesCache;

package/dist/cjs/onchain/market/pricefeeds/updates/RedstoneUpdater.js

@@ -0,0 +1,193 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_AddressMap = require("../../../utils/AddressMap.js");
+require("../../../utils/index.js");
+const require_onchain_base_SDKConstruct = require("../../../base/SDKConstruct.js");
+require("../../../base/index.js");
+const require_onchain_market_pricefeeds_updates_fetchRedstonePayloads = require("./fetchRedstonePayloads.js");
+const require_onchain_market_pricefeeds_updates_PriceUpdatesCache = require("./PriceUpdatesCache.js");
+const require_onchain_market_pricefeeds_updates_PriceUpdateTx = require("./PriceUpdateTx.js");
+let zod_v4 = require("zod/v4");
+//#region src/onchain/market/pricefeeds/updates/RedstoneUpdater.ts
+var RedstoneUpdateTx = class extends require_onchain_market_pricefeeds_updates_PriceUpdateTx.PriceUpdateTx {
+	name = "redstone";
+};
+const RedstoneOptions = zod_v4.z.object({
+	/**
+	* Fixed redstone historic timestamp in ms
+	* Set to true to enable redstone historical mode using timestamp from attach block
+	*/
+	historicTimestamp: zod_v4.z.union([zod_v4.z.number().nonnegative(), zod_v4.z.literal(true)]).optional(),
+	/**
+	* Override redstone gateways. Can be used to set caching proxies, to avoid rate limiting
+	*/
+	gateways: zod_v4.z.array(zod_v4.z.url()).optional(),
+	/**
+	* TTL for redstone cache in milliseconds
+	* If 0, disables caching
+	* If not set, uses some default value
+	* Cache is always enabled in historical mode
+	*/
+	cacheTTL: zod_v4.z.number().nonnegative().optional(),
+	/**
+	* When true, an error will be thrown when redstone is unable to fetch data for some feeds
+	*/
+	failOnMissingFeeds: zod_v4.z.boolean().optional(),
+	/**
+	* Enable redstone internal logging
+	*/
+	enableLogging: zod_v4.z.boolean().optional()
+});
+/**
+* Class to update multiple redstone price feeds at once
+*/
+var RedstoneUpdater = class extends require_onchain_base_SDKConstruct.SDKConstruct {
+	#cache;
+	#historicalTimestampMs;
+	#gateways;
+	#failOnMissingFeeds;
+	#enableLogging;
+	constructor(sdk, opts = {}) {
+		super(sdk);
+		this.#failOnMissingFeeds = opts.failOnMissingFeeds;
+		this.#enableLogging = opts.enableLogging;
+		this.#gateways = opts.gateways?.length ? opts.gateways : void 0;
+		let ts = opts.historicTimestamp;
+		if (ts) {
+			ts = ts === true ? Number(this.sdk.timestamp) * 1e3 : ts;
+			this.#historicalTimestampMs = 6e4 * Math.floor(ts / 6e4);
+			this.logger?.debug(`using historical timestamp ${this.#historicalTimestampMs}`);
+		}
+		this.#cache = opts.cache ?? new require_onchain_market_pricefeeds_updates_PriceUpdatesCache.PriceUpdatesCache({
+			ttl: opts.cacheTTL ?? 225e3,
+			historical: !!ts
+		});
+	}
+	async getUpdateTxs(feeds) {
+		if (feeds.length === 0) return [];
+		this.logger?.debug(`generating update transactions for ${feeds.length} redstone price feeds`);
+		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();
+			groupedFeeds[key].add(feed.dataId);
+			const pfsForDataId = priceFeeds.get(feed.dataId) ?? new require_onchain_utils_AddressMap.AddressMap();
+			pfsForDataId.upsert(feed.address, feed);
+			priceFeeds.set(feed.dataId, pfsForDataId);
+		}
+		const results = [];
+		let [minTimestamp, maxTimestamp] = [Number.POSITIVE_INFINITY, 0];
+		for (const [key, group] of Object.entries(groupedFeeds)) {
+			const [dataServiceId, signersStr] = key.split(":");
+			const uniqueSignersCount = parseInt(signersStr, 10);
+			const payloads = await this.#safeGetPayloads(dataServiceId, group, uniqueSignersCount);
+			for (const { dataFeedId, data, timestamp, cached } of payloads) {
+				const pfsForDataId = priceFeeds.get(dataFeedId);
+				if (!pfsForDataId) throw new Error(`cannot get price feed addresses for ${dataFeedId}`);
+				for (const priceFeed of pfsForDataId.values()) {
+					minTimestamp = Math.min(minTimestamp, timestamp);
+					maxTimestamp = Math.max(maxTimestamp, timestamp);
+					results.push(new RedstoneUpdateTx(priceFeed.createPriceUpdateTx(data), {
+						dataFeedId,
+						dataServiceId,
+						priceFeed: priceFeed.address,
+						timestamp,
+						cached
+					}));
+				}
+			}
+		}
+		let tsRange = "";
+		if (results.length) {
+			const minDelta = BigInt(minTimestamp) - this.sdk.timestamp;
+			tsRange = `, timestamps ${minTimestamp} (${minDelta})`;
+			if (minTimestamp !== maxTimestamp) {
+				const maxDelta = BigInt(maxTimestamp) - this.sdk.timestamp;
+				tsRange = `${tsRange} - ${maxTimestamp} (${maxDelta})`;
+			}
+		}
+		this.logger?.debug(`generated ${results.length} update transactions for redstone price feeds: ${Array.from(priceFeeds.keys()).join(", ")}${tsRange}`);
+		return results;
+	}
+	get historical() {
+		return !!this.#historicalTimestampMs;
+	}
+	/**
+	* Gets payloads, retries once if it has expired while inflight
+	* @param dataServiceId
+	* @param dataFeedsIds
+	* @param uniqueSignersCount
+	* @returns
+	*/
+	async #safeGetPayloads(dataServiceId, dataFeedsIds, uniqueSignersCount) {
+		let result = await this.#getPayloads(dataServiceId, dataFeedsIds, uniqueSignersCount);
+		if (this.#historicalTimestampMs) return result;
+		let expired = false;
+		for (const { timestamp, dataFeedId } of result) {
+			const delta = Number(this.sdk.timestamp) - timestamp;
+			if (delta >= 240 && delta < 255) {
+				this.logger?.warn(`payload for ${dataFeedId} has expired by ${delta} seconds`);
+				expired = true;
+			}
+		}
+		if (expired) result = await this.#getPayloads(dataServiceId, dataFeedsIds, uniqueSignersCount);
+		return result;
+	}
+	/**
+	* 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, dataFeedsIds, uniqueSignersCount) {
+		this.logger?.debug(`getting redstone payloads for ${dataFeedsIds.size} data feeds in ${dataServiceId} with ${uniqueSignersCount} signers: ${Array.from(dataFeedsIds).join(", ")}`);
+		const fromCache = [];
+		const uncached = [];
+		for (const dataFeedId of dataFeedsIds) {
+			const cached = this.#cache.get(dataServiceId, dataFeedId, uniqueSignersCount);
+			if (cached) fromCache.push({
+				...cached,
+				cached: true
+			});
+			else uncached.push(dataFeedId);
+		}
+		const fromRedstone = await this.#fetchPayloads(dataServiceId, new Set(uncached), uniqueSignersCount);
+		for (const resp of fromRedstone) this.#cache.set(resp, dataServiceId, resp.dataFeedId, uniqueSignersCount);
+		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, dataFeedsIds, uniqueSignersCount) {
+		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}`);
+		return require_onchain_market_pricefeeds_updates_fetchRedstonePayloads.fetchRedstonePayloads({
+			dataServiceId,
+			dataFeedsIds,
+			uniqueSignersCount,
+			historicalTimestampMs: this.#historicalTimestampMs,
+			gateways: this.#gateways,
+			failOnMissingFeeds: this.#failOnMissingFeeds,
+			enableLogging: this.#enableLogging,
+			logger: this.logger,
+			metadataTimestampMs: Number(this.sdk.timestamp) * 1e3
+		});
+	}
+};
+function isRedstone(pf) {
+	return pf.contractType === "PRICE_FEED::REDSTONE";
+}
+//#endregion
+exports.RedstoneOptions = RedstoneOptions;
+exports.RedstoneUpdater = RedstoneUpdater;

package/dist/cjs/onchain/market/pricefeeds/updates/fetchRedstonePayloads.js

@@ -0,0 +1,95 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_retry = require("../../../utils/retry.js");
+require("../../../utils/index.js");
+let viem = require("viem");
+let _redstone_finance_evm_connector = require("@redstone-finance/evm-connector");
+let _redstone_finance_protocol = require("@redstone-finance/protocol");
+let _redstone_finance_sdk = require("@redstone-finance/sdk");
+let _redstone_finance_utils = require("@redstone-finance/utils");
+//#region src/onchain/market/pricefeeds/updates/fetchRedstonePayloads.ts
+/**
+* Fetches redstone payloads from Redstone API
+*/
+async function fetchRedstonePayloads(options) {
+	const { dataServiceId, dataFeedsIds, uniqueSignersCount, historicalTimestampMs, gateways, failOnMissingFeeds, enableLogging, logger, returnPrices } = options;
+	const metadataTimestampMs = historicalTimestampMs ?? options.metadataTimestampMs;
+	const dataPackagesIds = Array.from(new Set(dataFeedsIds));
+	if (dataPackagesIds.length === 0) return [];
+	const wrapper = new _redstone_finance_evm_connector.DataServiceWrapper({
+		dataServiceId,
+		dataPackagesIds,
+		uniqueSignersCount,
+		authorizedSigners: (0, _redstone_finance_sdk.getSignersForDataServiceId)(dataServiceId),
+		historicalTimestamp: historicalTimestampMs,
+		urls: gateways,
+		ignoreMissingFeed: !failOnMissingFeeds,
+		enableEnhancedLogs: enableLogging
+	});
+	if (metadataTimestampMs) wrapper.setMetadataTimestamp(metadataTimestampMs);
+	const dataPayload = await require_onchain_utils_retry.retry(() => wrapper.prepareRedstonePayload(true), {
+		attempts: 5,
+		interval: historicalTimestampMs ? 30500 : 250
+	});
+	const packagesByDataFeedId = groupDataPackages(_redstone_finance_protocol.RedstonePayload.parse((0, viem.toBytes)(`0x${dataPayload}`)).signedDataPackages);
+	const result = [];
+	for (const dataFeedId of dataFeedsIds) {
+		const signedDataPackages = packagesByDataFeedId[dataFeedId];
+		if (!signedDataPackages) {
+			if (failOnMissingFeeds) throw new Error(`cannot find data packages for ${dataFeedId}`);
+			logger?.warn(`cannot find data packages for ${dataFeedId}`);
+			continue;
+		}
+		if (signedDataPackages.length !== uniqueSignersCount) {
+			if (failOnMissingFeeds) throw new Error(`got ${signedDataPackages.length} data packages for ${dataFeedId}, but expected ${uniqueSignersCount}`);
+			logger?.warn(`got ${signedDataPackages.length} data packages for ${dataFeedId}, but expected ${uniqueSignersCount}`);
+			continue;
+		}
+		result.push(getCalldataWithTimestamp(dataFeedId, signedDataPackages, wrapper.getUnsignedMetadata(), returnPrices));
+	}
+	return result;
+}
+/**
+* Groups SignedDataPackages by dataFeedId
+* @param signedDataPackages
+* @returns
+*/
+function groupDataPackages(signedDataPackages) {
+	const packagesByDataFeedId = {};
+	for (const p of signedDataPackages) {
+		const { dataPoints } = p.dataPackage;
+		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}`);
+		if (!packagesByDataFeedId[dataFeedId0]) packagesByDataFeedId[dataFeedId0] = [];
+		packagesByDataFeedId[dataFeedId0].push(p);
+	}
+	return packagesByDataFeedId;
+}
+function getCalldataWithTimestamp(dataFeedId, packages, unsignedMetadata, returnPrices) {
+	const bytesToAdd = 32 - _redstone_finance_protocol.RedstonePayload.prepare(packages, unsignedMetadata).length / 2 % 32;
+	const newUnsignedMetadata = unsignedMetadata + "_".repeat(bytesToAdd);
+	const payload = _redstone_finance_protocol.RedstonePayload.prepare(packages, newUnsignedMetadata);
+	let timestamp = 0;
+	for (const p of packages) {
+		const newTimestamp = p.dataPackage.timestampMilliseconds / 1e3;
+		if (timestamp === 0) timestamp = newTimestamp;
+		else if (timestamp !== newTimestamp) throw new Error("Timestamps are not equal");
+	}
+	const base = {
+		dataFeedId,
+		data: (0, viem.encodeAbiParameters)([{ type: "uint256" }, { type: "bytes" }], [BigInt(timestamp), `0x${payload}`]),
+		timestamp,
+		cached: false
+	};
+	if (returnPrices) {
+		const prices = packages.flatMap((p) => p.dataPackage.dataPoints).map((dp) => BigInt(`0x${Buffer.from(dp.value).toString("hex")}`));
+		const medianPrice = BigInt(_redstone_finance_utils.MathUtils.getMedianOfBigNumbers(prices));
+		return {
+			...base,
+			price: medianPrice,
+			decimals: 8
+		};
+	}
+	return base;
+}
+//#endregion
+exports.fetchRedstonePayloads = fetchRedstonePayloads;

package/dist/cjs/onchain/market/pricefeeds/updates/index.js

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_market_pricefeeds_updates_fetchRedstonePayloads = require("./fetchRedstonePayloads.js");
+const require_onchain_market_pricefeeds_updates_PriceUpdatesCache = require("./PriceUpdatesCache.js");
+const require_onchain_market_pricefeeds_updates_RedstoneUpdater = require("./RedstoneUpdater.js");
+exports.PriceUpdatesCache = require_onchain_market_pricefeeds_updates_PriceUpdatesCache.PriceUpdatesCache;
+exports.RedstoneOptions = require_onchain_market_pricefeeds_updates_RedstoneUpdater.RedstoneOptions;
+exports.RedstoneUpdater = require_onchain_market_pricefeeds_updates_RedstoneUpdater.RedstoneUpdater;
+exports.fetchRedstonePayloads = require_onchain_market_pricefeeds_updates_fetchRedstonePayloads.fetchRedstonePayloads;