@gearbox-protocol/sdk 18.2.0-next.10 → 18.2.0-next.11

package/dist/cjs/permissionless/api/oracles/score/formula.js

@@ -0,0 +1,99 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/permissionless/api/oracles/score/formula.ts
+/**
+* How well a market guards an asset's price, from its two feeds alone.
+*
+* Two questions, and the points are lost for each separately:
+*
+* - Would the reserve disagree with a main feed that has gone wrong? Only if
+*   it is a second feed on other sources. A missing reserve, a
+*   `ZeroPriceFeed`, the main feed again, and a different feed on the same
+*   sources all answer no.
+* - Is either feed bounded? A `BoundedPriceFeed` caps the answer from above,
+*   and a Gearbox LP feed clamps its exchange rate to a window.
+*
+* Independence costs more than the bound, 6 points against 5, because it is
+* the broader protection: a bounded feed caps only from above, and an LP
+* feed's window holds only its rate, not the price of what the rate is in.
+* Either failure alone lands a market at 4 or 5; both together at 0.
+*/
+const INDEPENDENCE_WEIGHT = 6;
+const BOUND_WEIGHT = 5;
+/**
+* The feed types that bound what they answer: the `BoundedPriceFeed`, and
+* every Gearbox LP feed, all of which clamp the rate they read.
+*/
+const BOUNDED_TYPE = /::(BOUNDED|ERC4626|CURVE_\w+|WSTETH|YEARN|MELLOW\w*|BALANCER\w*)$/;
+const ZERO_TYPE = "PRICE_FEED::ZERO";
+/**
+* The share of the two sides' sources that are not shared, by key.
+*
+* Nothing on either side — two hardcoded prices — is 0, because a reserve is
+* there to be a second opinion and neither of them is one.
+*/
+function independenceOf(main, reserve) {
+	const a = new Set(main.map((source) => source.key));
+	const b = new Set(reserve.map((source) => source.key));
+	const union = /* @__PURE__ */ new Set([...a, ...b]);
+	if (union.size === 0) return 0;
+	return 1 - [...a].filter((key) => b.has(key)).length / union.size;
+}
+/** Down to the half point, so that a score is never rounded up into a band. */
+function toHalf(value) {
+	return Math.floor(value * 2 + 1e-9) / 2;
+}
+/**
+* One market's score for one asset.
+*
+* `reserve` is `null` where the market holds no reserve for the asset at all.
+* A source is passed per side and keyed by the caller, which is where it is
+* decided that an unnamed source is its own contract and a named one is its
+* group.
+*/
+function scoreMarket(market, main, reserve) {
+	const reasons = [];
+	let hasReserve = true;
+	if (reserve === null) {
+		hasReserve = false;
+		reasons.push("no reserve feed");
+	} else if (reserve.feed.contractType === ZERO_TYPE) {
+		hasReserve = false;
+		reasons.push("reserve is a ZeroPriceFeed");
+	} else if (reserve.feed.feed.toLowerCase() === main.feed.feed.toLowerCase()) {
+		hasReserve = false;
+		reasons.push("reserve is the main feed");
+	}
+	const reserveSources = hasReserve && reserve ? reserve.sources : [];
+	const independence = hasReserve ? independenceOf(main.sources, reserveSources) : 0;
+	const reserveKeys = new Set(reserveSources.map((source) => source.key));
+	const mainKeys = new Set(main.sources.map((source) => source.key));
+	const shared = main.sources.filter((source) => reserveKeys.has(source.key));
+	const names = (sources) => [...new Set(sources.map((source) => source.name))];
+	if (hasReserve && independence < 1) reasons.push(shared.length > 0 ? `main and reserve share ${names(shared).join(", ")}` : "neither feed reads a price source");
+	const unverified = hasReserve && [...main.sources.filter((source) => !reserveKeys.has(source.key)), ...reserveSources.filter((source) => !mainKeys.has(source.key))].some((source) => !source.identified);
+	const bounded = BOUNDED_TYPE.test(main.feed.contractType) || reserve !== null && BOUNDED_TYPE.test(reserve.feed.contractType);
+	if (!bounded) reasons.push("neither feed is bounded");
+	const score = toHalf(Math.max(0, 10 - 6 * (1 - independence) - 5 * (bounded ? 0 : 1)));
+	return {
+		...market,
+		main: {
+			...main.feed,
+			sources: names(main.sources)
+		},
+		reserve: reserve ? {
+			...reserve.feed,
+			sources: names(reserve.sources)
+		} : null,
+		hasReserve,
+		independence,
+		bounded,
+		sharedSources: names(shared),
+		unverified,
+		score,
+		reasons
+	};
+}
+//#endregion
+exports.BOUND_WEIGHT = BOUND_WEIGHT;
+exports.INDEPENDENCE_WEIGHT = INDEPENDENCE_WEIGHT;
+exports.scoreMarket = scoreMarket;

package/dist/cjs/permissionless/api/oracles/score/index.js

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_oracles_score_formula = require("./formula.js");
+const require_permissionless_api_oracles_score_run = require("./run.js");
+require("./types.js");
+exports.BOUND_WEIGHT = require_permissionless_api_oracles_score_formula.BOUND_WEIGHT;
+exports.INDEPENDENCE_WEIGHT = require_permissionless_api_oracles_score_formula.INDEPENDENCE_WEIGHT;
+exports.runAssetScores = require_permissionless_api_oracles_score_run.runAssetScores;
+exports.scoreMarket = require_permissionless_api_oracles_score_formula.scoreMarket;

package/dist/cjs/permissionless/api/oracles/score/run.js

@@ -0,0 +1,88 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_oracles_stress_classify = require("../stress/classify.js");
+const require_permissionless_api_oracles_stress_run = require("../stress/run.js");
+const require_permissionless_api_oracles_score_formula = require("./formula.js");
+//#region src/permissionless/api/oracles/score/run.ts
+/**
+* How a source is told apart from another when two feeds are compared.
+*
+* A named source by its group, since two Chainlink aggregators are one
+* provider failing together. An unnamed one by its contract, since nothing
+* says what else it fails with — so the same contract on both sides is
+* shared, and two different ones are not.
+*/
+function toScoreSource(source) {
+	return {
+		key: source.identified ? `group:${source.group}` : `contract:${source.target}`,
+		name: source.group,
+		identified: source.identified
+	};
+}
+/**
+* Every asset of one chain, scored by how its running markets price it.
+*
+* One read of every oracle's feed tree and one of the LP feeds' rate
+* contracts, both multicalls: the score is a reading of the trees and needs
+* no simulation.
+**/
+async function runAssetScores({ client, chainId, slots, compressor, logger }) {
+	const running = slots.filter((slot) => !slot.isShutdown);
+	const oracles = [...new Set(running.map((slot) => slot.priceOracle.toLowerCase()))];
+	const { nodes, unreadableOracles } = await require_permissionless_api_oracles_stress_run.readForest(client, compressor, oracles);
+	for (const oracle of unreadableOracles) logger?.warn(`price oracle ${oracle} of chain ${chainId} would not report its feed tree; the markets on it are not scored`);
+	const { targets } = await require_permissionless_api_oracles_stress_run.readRateTargets(client, [...nodes.values()].filter((node) => require_permissionless_api_oracles_stress_run.RATE_FEED_TYPE.test(node.contractType)).map((node) => node.address));
+	const { sources } = require_permissionless_api_oracles_stress_classify.classifySources(chainId, [...nodes.values()], targets, () => null);
+	const byTarget = new Map(sources.filter((source) => source.perturbable).map((source) => [source.target, toScoreSource(source)]));
+	const feedOf = (slot) => slot.priceFeed.toLowerCase();
+	const reach = require_permissionless_api_oracles_stress_classify.sourcesByFeed([...new Set(running.map(feedOf))], nodes, sources);
+	const sourcesOf = (feed) => [...reach.get(feed) ?? []].map((target) => byTarget.get(target)).filter((source) => source !== void 0);
+	const positions = /* @__PURE__ */ new Map();
+	for (const slot of running) {
+		const key = `${slot.market.toLowerCase()}:${slot.token.toLowerCase()}`;
+		const position = positions.get(key) ?? {};
+		position[slot.reserve ? "reserve" : "main"] = slot;
+		positions.set(key, position);
+	}
+	const byAsset = /* @__PURE__ */ new Map();
+	for (const { main, reserve } of positions.values()) {
+		if (!main || main.isUnderlying) continue;
+		const asset = main.token.toLowerCase();
+		const entry = byAsset.get(asset) ?? {
+			symbol: main.tokenSymbol,
+			markets: []
+		};
+		byAsset.set(asset, entry);
+		const mainNode = nodes.get(feedOf(main));
+		if (!mainNode) continue;
+		if (mainNode.contractType === "PRICE_FEED::ZERO") continue;
+		const side = (slot) => ({
+			feed: {
+				feed: feedOf(slot),
+				name: slot.priceFeedName,
+				contractType: nodes.get(feedOf(slot))?.contractType ?? ""
+			},
+			sources: sourcesOf(feedOf(slot))
+		});
+		entry.markets.push(require_permissionless_api_oracles_score_formula.scoreMarket({
+			market: main.market,
+			marketName: main.marketName,
+			marketConfigurator: main.marketConfigurator,
+			curatorName: main.curatorName
+		}, side(main), reserve ? side(reserve) : null));
+	}
+	return [...byAsset].map(([asset, { symbol, markets }]) => {
+		const sorted = markets.sort((a, b) => a.score - b.score);
+		const worst = sorted[0] ?? null;
+		return {
+			chainId,
+			asset,
+			symbol,
+			score: worst?.score ?? null,
+			unverified: sorted.some((market) => market.unverified),
+			worst,
+			markets: sorted
+		};
+	});
+}
+//#endregion
+exports.runAssetScores = runAssetScores;

package/dist/cjs/permissionless/api/oracles/score/types.js

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/cjs/permissionless/api/oracles/stress/classify.js

@@ -0,0 +1,258 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/permissionless/api/oracles/stress/classify.ts
+/**
+* The feed types whose price is a protocol's exchange rate read off a
+* contract, mapped to the group that rate belongs to.
+*
+* These are not leaves: an LP feed also reads the price of whatever the rate
+* is denominated in, and that child is somebody else's source. What belongs to
+* the protocol is the rate alone, which is why these are perturbed at the
+* contract the feed reads it from rather than at the feed.
+*
+* `null` means the protocol is the vault's own and has to come from
+* {@link VAULT_GROUPS} or, failing that, from the feed's description.
+*/
+const RATE_TYPE_GROUPS = {
+	WSTETH: "Lido",
+	CURVE_STABLE: "Curve",
+	CURVE_CRYPTO: "Curve",
+	CURVE_TWAP: "Curve",
+	YEARN: "Yearn",
+	MELLOW_LRT: "Mellow",
+	BALANCER_STABLE: "Balancer",
+	BALANCER_WEIGHTED: "Balancer",
+	ERC4626: null
+};
+/**
+* Which protocol an ERC-4626 vault belongs to, by the symbol its feed is
+* described with.
+*
+* Curated, and deliberately short: a vault not named here becomes a group of
+* one under its own symbol, which is still a correct partition — one vault is
+* one source — and is flagged so a reader knows nothing claims it fails
+* alongside anything else.
+*/
+const VAULT_GROUPS = {
+	sUSDS: "Sky",
+	sDAI: "Sky",
+	sUSDe: "Ethena",
+	sUSDf: "Falcon",
+	wstUSR: "Resolv",
+	syrupUSDC: "Maple",
+	hgETH: "Kelp",
+	rstETH: "Mellow",
+	Re7LRT: "Mellow",
+	pzETH: "Mellow",
+	DVstETH: "Mellow",
+	tETH: "Treehouse"
+};
+/**
+* Rules over a Chainlink-shaped feed's own description, in order.
+*
+* Only reached for a leaf Gearbox did not deploy, which is where the provider
+* is not already stated. The first match wins, so the specific patterns come
+* before the general shape of a Chainlink pair.
+*/
+const DESCRIPTION_RULES = [
+	{
+		via: "description names Redstone",
+		match: /redstone/i,
+		group: "Redstone"
+	},
+	{
+		via: "description names Pyth",
+		match: /\bpyth\b/i,
+		group: "Pyth"
+	},
+	{
+		via: "description names Pendle",
+		match: /pendle/i,
+		group: "Pendle"
+	},
+	{
+		via: "description names Chronicle",
+		match: /chronicle/i,
+		group: "Chronicle"
+	},
+	{
+		via: "description names API3",
+		match: /\bapi3\b/i,
+		group: "API3"
+	},
+	{
+		via: "description names Chaos",
+		match: /chaos\s*labs/i,
+		group: "Chaos Labs"
+	},
+	{
+		via: "Midas naming convention",
+		match: /^m(TBILL|BASIS|EDGE|F-ONE|GLOBAL|Re7YIELD|[A-Z]{2,}[0-9]*)\s*\//,
+		group: "Midas"
+	},
+	{
+		via: "exchange-rate adapter, grouped by its token",
+		match: /^([A-Za-z0-9+]+)\s*[/-]\s*[A-Za-z0-9+]+\s+exchange\s+rate/i,
+		group: (m) => m[1]
+	}
+];
+/**
+* Whether a description is a Chainlink pair: `BASE / QUOTE`, spaced, in the
+* shape their aggregators have published for years.
+*
+* Paired with a version of 6, which is what `EACAggregatorProxy` answers and
+* what the imitators — version 0 or 1, mostly — do not. Either alone would be
+* wrong: plenty of adapters describe themselves as a spaced pair, and plenty
+* of Chainlink feeds are read through a wrapper that reports another version.
+*/
+const CHAINLINK_PAIR = /^[A-Za-z0-9+]+ \/ [A-Za-z0-9+]+$/;
+/** Feed types that are their own answer, with no source behind them at all. */
+const SELF_CONTAINED = {
+	CONSTANT: "Constant",
+	ZERO: "Zero"
+};
+/** The type without the `PRICE_FEED::` the bytecode repository prefixes it with. */
+function bareType(contractType) {
+	return contractType.replace(/^PRICE_FEED::/, "");
+}
+/**
+* Which group a leaf price feed belongs to, and how that was decided.
+*
+* The order is what makes it defensible: what Gearbox deployed says who it
+* reads, so those types are taken first; then the description rules, most
+* specific first; then the Chainlink shape; and anything left is its own group
+* under its own description, flagged.
+*/
+function classifyLeaf(node) {
+	const type = bareType(node.contractType);
+	const selfContained = SELF_CONTAINED[type];
+	if (selfContained) return {
+		group: selfContained,
+		identified: true,
+		via: "Gearbox feed type"
+	};
+	if (type === "REDSTONE" || type === "PYTH" || type === "CHAINLINK") return {
+		group: type === "PYTH" ? "Pyth" : type === "REDSTONE" ? "Redstone" : "Chainlink",
+		identified: true,
+		via: "Gearbox feed type"
+	};
+	for (const rule of DESCRIPTION_RULES) {
+		const m = node.description.match(rule.match);
+		if (m) return {
+			group: typeof rule.group === "function" ? rule.group(m) : rule.group,
+			identified: true,
+			via: rule.via
+		};
+	}
+	if (CHAINLINK_PAIR.test(node.description) && node.version === 6) return {
+		group: "Chainlink",
+		identified: true,
+		via: "Chainlink pair description at interface version 6"
+	};
+	return {
+		group: node.description || node.address,
+		identified: false,
+		via: "unrecognised: grouped alone under its own description"
+	};
+}
+/**
+* Which group a rate-bearing feed's rate belongs to.
+*
+* The type names the protocol for everything but an ERC-4626 vault, where the
+* protocol is the vault's own and is looked up by the symbol the feed is
+* described with — `"sUSDS / USD LP price feed"` is Sky's.
+*/
+function classifyRate(node) {
+	const type = bareType(node.contractType);
+	const named = RATE_TYPE_GROUPS[type];
+	if (named) return {
+		group: named,
+		identified: true,
+		via: "Gearbox feed type"
+	};
+	const symbol = node.description.match(/^([A-Za-z0-9+.-]+)\s*\//)?.[1];
+	const protocol = symbol ? VAULT_GROUPS[symbol] : void 0;
+	if (protocol) return {
+		group: protocol,
+		identified: true,
+		via: "curated vault table"
+	};
+	return {
+		group: symbol ?? node.address,
+		identified: false,
+		via: "vault not in the curated table: grouped alone under its symbol"
+	};
+}
+/**
+* Every source behind a chain's feed trees.
+*
+* A source per contract, not per feed: two of an oracle's trees carrying the
+* same aggregator is one source read twice, and the test varies it once.
+*
+* `rateTargets` says which contract each rate-bearing feed reads its rate
+* from — the feed's own `lpContract`, read separately because the compressor
+* does not report it. A feed missing from it is left out with a reason, since
+* perturbing the whole feed instead would charge its protocol with a failure
+* of whatever prices the thing the rate is denominated in.
+**/
+function classifySources(chainId, nodes, rateTargets, baselineOf) {
+	const sources = [];
+	const unresolved = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const node of nodes) {
+		const isRate = bareType(node.contractType) in RATE_TYPE_GROUPS;
+		if (!isRate && node.underlyingFeeds.length > 0) continue;
+		const target = isRate ? rateTargets.get(node.address) : node.address;
+		if (!target) {
+			unresolved.push(node);
+			continue;
+		}
+		if (seen.has(target)) continue;
+		seen.add(target);
+		sources.push({
+			chainId,
+			kind: isRate ? "rate" : "feed",
+			target,
+			feed: node.address,
+			contractType: node.contractType,
+			description: node.description,
+			perturbable: !(bareType(node.contractType) in SELF_CONTAINED),
+			baseline: baselineOf(target),
+			...isRate ? classifyRate(node) : classifyLeaf(node)
+		});
+	}
+	return {
+		sources,
+		unresolved
+	};
+}
+/**
+* The sources each of the given feeds is priced through, following the trees
+* down from every one of them.
+*
+* A feed is reached by a source when the source sits anywhere beneath it, at
+* any depth: a market reading a composite of a composite of a Chainlink
+* aggregator is a market Chainlink can move. Memoised over the whole forest,
+* so a node shared by twenty trees is walked once.
+**/
+function sourcesByFeed(roots, nodes, sources) {
+	const sourceOfFeed = /* @__PURE__ */ new Map();
+	for (const source of sources) sourceOfFeed.set(source.feed, source.target);
+	const memo = /* @__PURE__ */ new Map();
+	const walk = (feed, path) => {
+		const done = memo.get(feed);
+		if (done) return done;
+		if (path.has(feed)) return /* @__PURE__ */ new Set();
+		const found = /* @__PURE__ */ new Set();
+		const own = sourceOfFeed.get(feed);
+		if (own) found.add(own);
+		path.add(feed);
+		for (const child of nodes.get(feed)?.underlyingFeeds ?? []) for (const source of walk(child, path)) found.add(source);
+		path.delete(feed);
+		memo.set(feed, found);
+		return found;
+	};
+	return new Map(roots.map((root) => [root, walk(root, /* @__PURE__ */ new Set())]));
+}
+//#endregion
+exports.classifySources = classifySources;
+exports.sourcesByFeed = sourcesByFeed;

package/dist/cjs/permissionless/api/oracles/stress/index.js

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_oracles_stress_classify = require("./classify.js");
+const require_permissionless_api_oracles_stress_override = require("./override.js");
+const require_permissionless_api_oracles_stress_score = require("./score.js");
+const require_permissionless_api_oracles_stress_run = require("./run.js");
+require("./types.js");
+exports.DEFAULT_SCENARIOS = require_permissionless_api_oracles_stress_run.DEFAULT_SCENARIOS;
+exports.RATE_FEED_TYPE = require_permissionless_api_oracles_stress_run.RATE_FEED_TYPE;
+exports.UNBOUNDED_DOWN = require_permissionless_api_oracles_stress_override.UNBOUNDED_DOWN;
+exports.UNBOUNDED_UP = require_permissionless_api_oracles_stress_override.UNBOUNDED_UP;
+exports.classifySources = require_permissionless_api_oracles_stress_classify.classifySources;
+exports.groupOverride = require_permissionless_api_oracles_stress_override.groupOverride;
+exports.perturb = require_permissionless_api_oracles_stress_override.perturb;
+exports.rateStub = require_permissionless_api_oracles_stress_override.rateStub;
+exports.readForest = require_permissionless_api_oracles_stress_run.readForest;
+exports.readRateTargets = require_permissionless_api_oracles_stress_run.readRateTargets;
+exports.roundDataStub = require_permissionless_api_oracles_stress_override.roundDataStub;
+exports.runStressTest = require_permissionless_api_oracles_stress_run.runStressTest;
+exports.scoreGroup = require_permissionless_api_oracles_stress_score.scoreGroup;
+exports.slotHarm = require_permissionless_api_oracles_stress_score.slotHarm;
+exports.sourcesByFeed = require_permissionless_api_oracles_stress_classify.sourcesByFeed;
+exports.verdictOf = require_permissionless_api_oracles_stress_score.verdictOf;

package/dist/cjs/permissionless/api/oracles/stress/override.js

@@ -0,0 +1,125 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/permissionless/api/oracles/stress/override.ts
+/**
+* Making a contract lie for the length of one `eth_call`.
+*
+* No fork and no simulation harness: an `eth_call` carries a state override,
+* so the aggregator's code is replaced for that call alone and everything
+* above it — the composite feeds, their bounds, the oracle's own checks — runs
+* as deployed, on real state, at the current block. What comes back is what
+* the market would have read.
+**/
+/** A word, as the 32 bytes `PUSH32` wants, two's complement for negatives. */
+function word(value) {
+	return BigInt.asUintN(256, value).toString(16).padStart(64, "0");
+}
+/**
+* Runtime code answering every call with the same five words.
+*
+* Deliberately selector-blind. A price feed is read through more than
+* `latestRoundData` — `decimals`, `version`, sometimes `latestAnswer` — and
+* dispatching on each would mean knowing which of them every caller in a tree
+* reaches for. Five words decode as the round data; a caller expecting one
+* word reads the first, which is why `roundId` is set to the 8 decimals every
+* Gearbox feed reports rather than to a round number.
+*
+* `answeredInRound` is the same 8, so the `answeredInRound >= roundId` check
+* the older consumers make passes.
+**/
+function roundDataStub(answer, updatedAt) {
+	return `0x${[
+		`7f${word(8n)}600052`,
+		`7f${word(answer)}602052`,
+		`7f${word(updatedAt)}604052`,
+		`7f${word(updatedAt)}606052`,
+		`7f${word(8n)}608052`,
+		"60a06000f3"
+	].join("")}`;
+}
+/**
+* Runtime code answering every call with one word.
+*
+* What an exchange rate getter returns, whichever of them the feed calls:
+* `stEthPerToken`, `convertToAssets`, `get_virtual_price`, `pricePerShare`
+* and `getRate` all answer a single `uint256`, so the stub does not need to
+* know which.
+**/
+function rateStub(rate) {
+	return `0x7f${word(rate)}60005260206000f3`;
+}
+/**
+* The two unbounded ends, as far as the types involved can carry them.
+*
+* "Infinitely large" has to stop somewhere: a price is an `int256` and the
+* arithmetic above it multiplies, so a genuinely enormous answer overflows
+* inside the composite feed and reverts — which would be scored as the
+* oracle resisting, when all that happened is that the test asked something
+* the type cannot hold. `1e12` times the current answer is past any bound,
+* any sanity check and any collateral ratio, and still multiplies.
+*/
+const UNBOUNDED_UP = 0xe8d4a51000;
+/** The other end: a thousandth of a trillionth, which is as near zero. */
+const UNBOUNDED_DOWN = 1e-12;
+/**
+* A double as an exact integer ratio.
+*
+* Multipliers here span twenty-four orders of magnitude, so the obvious
+* `BigInt(Math.round(m * 1e9))` is not available: at the top of the range the
+* product is past what a double carries exactly and the multiplier quietly
+* stops being the one that was asked for. Going through the decimal expansion
+* keeps all fifteen digits a double has and puts the magnitude in the
+* exponent, where it costs nothing.
+*/
+function asRatio(multiplier) {
+	const [mantissa = "0", exponent = "0"] = multiplier.toExponential(14).split("e");
+	const digits = BigInt(mantissa.replace(".", ""));
+	const power = Number(exponent) - 14;
+	return power >= 0 ? {
+		num: digits * 10n ** BigInt(power),
+		den: 1n
+	} : {
+		num: digits,
+		den: 10n ** BigInt(-power)
+	};
+}
+/**
+* What a source should answer under a multiplier, given what it answers now.
+*
+* Floored at one rather than at zero: a multiplier small enough to round the
+* baseline away would be testing a feed reporting nothing, which is the revert
+* case and is a different scenario with a different meaning.
+*/
+function perturb(baseline, multiplier) {
+	const { num, den } = asRatio(Number.isFinite(multiplier) ? Math.min(Math.max(multiplier, UNBOUNDED_DOWN), UNBOUNDED_UP) : multiplier > 0 ? UNBOUNDED_UP : UNBOUNDED_DOWN);
+	const out = baseline * num / den;
+	return out === 0n ? 1n : out;
+}
+/**
+* The state override that makes every source of a group answer a multiple of
+* what it answers now.
+*
+* One override per contract, so a group whose sources share an aggregator
+* perturbs it once. Sources with nothing behind them and sources that are not
+* answering are both left out, for the reasons on
+* {@link StressSource.perturbable} and {@link StressSource.baseline} — an
+* empty result is a group there is nothing to simulate about.
+**/
+function groupOverride(sources, multiplier, updatedAt) {
+	const overrides = [];
+	for (const source of sources) {
+		if (!source.perturbable || source.baseline === null) continue;
+		const value = perturb(source.baseline, multiplier);
+		overrides.push({
+			address: source.target,
+			code: source.kind === "rate" ? rateStub(value) : roundDataStub(value, updatedAt)
+		});
+	}
+	return overrides;
+}
+//#endregion
+exports.UNBOUNDED_DOWN = UNBOUNDED_DOWN;
+exports.UNBOUNDED_UP = UNBOUNDED_UP;
+exports.groupOverride = groupOverride;
+exports.perturb = perturb;
+exports.rateStub = rateStub;
+exports.roundDataStub = roundDataStub;