@gearbox-protocol/sdk 18.2.0-next.13 → 18.2.0-next.14

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

@@ -1,63 +1,72 @@
 import { classifySources, sourcesByFeed } from "../stress/classify.js";
-import { RATE_FEED_TYPE, readForest, readRateTargets, readUnder } from "../stress/run.js";
+import { RATE_FEED_TYPE, readFeedTrees, readForest, readRateTargets, readUnder } from "../stress/run.js";
 import { factorOf, finalPrice, scoreOfFactor, worstOf } from "./formula.js";
 import { formatUnits } from "viem";
 //#region src/permissionless/api/oracles/score/run.ts
 const ZERO_TYPE = "PRICE_FEED::ZERO";
 /** Groups simulated at once: one `eth_call` each, all against one node. */
 const CONCURRENCY = 6;
-const feedOf = (slot) => slot.priceFeed.toLowerCase();
+const lower = (address) => address.toLowerCase();
 /**
-* Every asset of one chain, scored by what each of its source groups can do
-* to the price its running markets hold for it.
+* A main feed and the reserve a slot or a caller names for it, as the score
+* takes them: a reserve that is a `ZeroPriceFeed` is no reserve.
+*/
+function pairOf(main, reserve, nodes) {
+	const notes = [];
+	if (!reserve) {
+		notes.push("no reserve feed");
+		return {
+			main,
+			reserve: void 0,
+			notes
+		};
+	}
+	if (nodes.get(reserve)?.contractType === ZERO_TYPE) {
+		notes.push("reserve is a ZeroPriceFeed");
+		return {
+			main,
+			reserve: void 0,
+			notes
+		};
+	}
+	if (reserve === main) notes.push("reserve is the main feed");
+	return {
+		main,
+		reserve,
+		notes
+	};
+}
+/**
+* Every pair's final price under each source group lying, from one read of
+* the LP feeds' rate contracts, one of every feed as it stands, and then one
+* `eth_call` per source group with the group's sources overridden to answer
+* {@link SCORE_MULTIPLIER} times what they answer now.
 *
-* One read of the oracles' feed trees, one of the LP feeds' rate contracts,
-* one of every market feed as it stands — then one `eth_call` per source
-* group, with the group's sources overridden to answer
-* {@link SCORE_MULTIPLIER} times what they answer now and every market feed
-* read under it.
-**/
-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, answers, unreadableOracles } = await 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`);
+* A pair whose final price does not answer as it stands comes back `null`:
+* there is no price to move.
+*/
+async function simulatePairs({ client, chainId, nodes, answers, pairs, logger }) {
 	const { targets, baselines: rateBaselines } = await readRateTargets(client, [...nodes.values()].filter((node) => RATE_FEED_TYPE.test(node.contractType)).map((node) => node.address));
 	const { sources, unresolved } = classifySources(chainId, [...nodes.values()], targets, (target) => rateBaselines.get(target) ?? answers.get(target) ?? null);
 	for (const node of unresolved) logger?.warn(`feed ${node.address} of chain ${chainId} would not say what it reads its rate from; its protocol is not perturbed`);
-	const slotsByPosition = /* @__PURE__ */ new Map();
-	for (const slot of running) {
-		const key = `${slot.market.toLowerCase()}:${slot.token.toLowerCase()}`;
-		const entry = slotsByPosition.get(key) ?? {};
-		entry[slot.reserve ? "reserve" : "main"] = slot;
-		slotsByPosition.set(key, entry);
-	}
-	const positions = [];
-	for (const { main, reserve } of slotsByPosition.values()) {
-		if (!main || main.isUnderlying) continue;
-		const mainNode = nodes.get(feedOf(main));
-		if (!mainNode || mainNode.contractType === ZERO_TYPE) continue;
-		const notes = [];
-		let reserveFeed;
-		if (!reserve) notes.push("no reserve feed");
-		else if (nodes.get(feedOf(reserve))?.contractType === ZERO_TYPE) notes.push("reserve is a ZeroPriceFeed");
-		else {
-			reserveFeed = feedOf(reserve);
-			if (reserveFeed === feedOf(main)) notes.push("reserve is the main feed");
+	const roots = [...new Set(pairs.flatMap(({ main, reserve }) => reserve ? [main, reserve] : [main]))];
+	const reach = sourcesByFeed(roots, nodes, sources);
+	const sourceByTarget = new Map(sources.map((source) => [source.target, source]));
+	const drivable = (source) => source !== void 0 && source.perturbable && source.baseline !== null;
+	const groupsOf = (feed) => {
+		const out = /* @__PURE__ */ new Map();
+		for (const target of feed ? reach.get(feed) ?? [] : []) {
+			const source = sourceByTarget.get(target);
+			if (drivable(source)) out.set(source.group, [...out.get(source.group) ?? [], source]);
 		}
-		positions.push({
-			main,
-			reserve,
-			reserveFeed,
-			notes
-		});
-	}
-	const priced = [...new Set(positions.flatMap(({ main, reserveFeed }) => reserveFeed ? [feedOf(main), reserveFeed] : [feedOf(main)]))];
-	if (priced.length === 0) return [];
-	const underlyingOf = (slot) => slot.underlyingPriceFeed?.toLowerCase();
-	const roots = [.../* @__PURE__ */ new Set([...priced, ...positions.map(({ main }) => underlyingOf(main)).filter((feed) => feed !== void 0)])];
+		return out;
+	};
+	const sourcesOf = (feed) => [...groupsOf(feed).keys()];
+	if (roots.length === 0) return {
+		results: [],
+		sourcesOf
+	};
 	const updatedAt = BigInt(Math.floor(Date.now() / 1e3));
-	const drivable = (source) => source !== void 0 && source.perturbable && source.baseline !== null;
 	const fresh = sources.filter((source) => drivable(source) && source.kind === "feed");
 	const asIs = await readUnder(client, roots, [], 1, updatedAt);
 	const stale = roots.filter((root) => (asIs.get(root) ?? null) === null);
@@ -67,72 +76,105 @@ async function runAssetScores({ client, chainId, slots, compressor, logger }) {
 	const freshRoots = stale.filter((root) => (freshened.get(root) ?? null) !== null);
 	/** Every root under a lie, each read the way its base was. */
 	const readLying = async (members) => {
-		const [plain, refreshed] = await Promise.all([asIsRoots.length > 0 ? readUnder(client, asIsRoots, members, 5, updatedAt) : /* @__PURE__ */ new Map(), freshRoots.length > 0 ? readUnder(client, freshRoots, members, 5, updatedAt, fresh) : /* @__PURE__ */ new Map()]);
+		const [plain, refreshed] = await Promise.all([asIsRoots.length > 0 ? readUnder(client, asIsRoots, members, 10, updatedAt) : /* @__PURE__ */ new Map(), freshRoots.length > 0 ? readUnder(client, freshRoots, members, 10, updatedAt, fresh) : /* @__PURE__ */ new Map()]);
 		return new Map([...plain, ...refreshed]);
 	};
-	for (const position of positions) if (position.reserveFeed && (base.get(position.reserveFeed) ?? null) === null) {
-		position.reserveFeed = void 0;
-		position.notes.push("reserve does not answer");
-	}
-	const reach = sourcesByFeed(roots, nodes, sources);
-	const sourceByTarget = new Map(sources.map((source) => [source.target, source]));
+	const effective = pairs.map((pair) => pair.reserve && (base.get(pair.reserve) ?? null) === null ? {
+		...pair,
+		reserve: void 0,
+		notes: [...pair.notes, "reserve does not answer"]
+	} : pair);
 	const byGroup = /* @__PURE__ */ new Map();
 	for (const source of sources.filter(drivable)) byGroup.set(source.group, [...byGroup.get(source.group) ?? [], source]);
 	const reachedGroups = /* @__PURE__ */ new Set();
-	for (const root of priced) for (const target of reach.get(root) ?? []) {
-		const source = sourceByTarget.get(target);
-		if (drivable(source)) reachedGroups.add(source.group);
-	}
+	for (const root of roots) for (const group of groupsOf(root).keys()) reachedGroups.add(group);
 	const stressed = /* @__PURE__ */ new Map();
 	const queue = [...reachedGroups];
 	for (let i = 0; i < queue.length; i += CONCURRENCY) await Promise.all(queue.slice(i, i + CONCURRENCY).map(async (group) => {
 		stressed.set(group, await readLying(byGroup.get(group) ?? []));
 	}));
-	const groupsOf = (feed) => {
-		const out = /* @__PURE__ */ new Map();
-		for (const target of feed ? reach.get(feed) ?? [] : []) {
-			const source = sourceByTarget.get(target);
-			if (drivable(source)) out.set(source.group, [...out.get(source.group) ?? [], source]);
-		}
-		return out;
-	};
-	const byAsset = /* @__PURE__ */ new Map();
-	for (const { main, reserve, reserveFeed, notes } of positions) {
-		const mainFeed = feedOf(main);
-		const before = finalPrice(base.get(mainFeed) ?? null, reserveFeed ? base.get(reserveFeed) ?? null : void 0);
-		if (before === null || before <= 0n) {
-			logger?.warn(`feed ${mainFeed} of chain ${chainId} does not answer; ${main.tokenSymbol ?? main.token} in ${main.marketName ?? main.market} is not scored`);
-			continue;
-		}
-		const onMain = groupsOf(mainFeed);
-		const onReserve = groupsOf(reserveFeed);
-		const impacts = [.../* @__PURE__ */ new Set([...onMain.keys(), ...onReserve.keys()])].map((group) => {
-			const under = stressed.get(group) ?? /* @__PURE__ */ new Map();
-			const after = finalPrice(under.get(mainFeed) ?? null, reserveFeed ? under.get(reserveFeed) ?? null : void 0);
-			const factor = factorOf(before, after);
-			const underlying = underlyingOf(main);
-			const debtBefore = underlying ? base.get(underlying) ?? null : null;
-			const debtFactor = debtBefore === null || debtBefore <= 0n || !underlying ? null : factorOf(debtBefore, under.get(underlying) ?? null);
-			const ratioFactor = factor === null || debtFactor === null || debtFactor === 0 ? null : factor / debtFactor;
-			const members = [...onMain.get(group) ?? [], ...onReserve.get(group) ?? []];
+	return {
+		results: effective.map(({ main, reserve, notes }) => {
+			const before = finalPrice(base.get(main) ?? null, reserve ? base.get(reserve) ?? null : void 0);
+			if (before === null || before <= 0n) return null;
+			const onMain = groupsOf(main);
+			const onReserve = groupsOf(reserve);
+			const impacts = [.../* @__PURE__ */ new Set([...onMain.keys(), ...onReserve.keys()])].map((group) => {
+				const under = stressed.get(group) ?? /* @__PURE__ */ new Map();
+				const after = finalPrice(under.get(main) ?? null, reserve ? under.get(reserve) ?? null : void 0);
+				const factor = factorOf(before, after);
+				const members = [...onMain.get(group) ?? [], ...onReserve.get(group) ?? []];
+				return {
+					group,
+					identified: members.every((source) => source.identified),
+					feeds: [...new Set(members.map((source) => source.description))],
+					reaches: onMain.has(group) ? onReserve.has(group) ? "both" : "main" : "reserve",
+					factor,
+					score: scoreOfFactor(factor)
+				};
+			});
 			return {
-				group,
-				identified: members.every((source) => source.identified),
-				feeds: [...new Set(members.map((source) => source.description))],
-				reaches: onMain.has(group) ? onReserve.has(group) ? "both" : "main" : "reserve",
-				factor,
-				ratioFactor,
-				score: scoreOfFactor(factor)
+				hasReserve: reserve !== void 0,
+				price: Number(formatUnits(before, 8)),
+				unverified: reserve !== void 0 && impacts.some((impact) => !impact.identified && impact.reaches !== "both"),
+				notes,
+				...worstOf(impacts)
 			};
+		}),
+		sourcesOf
+	};
+}
+/**
+* Every asset of one chain, scored by what each of its source groups can do
+* to the price its running markets hold for it.
+*
+* One read of the oracles' feed trees, then the simulation of every market's
+* main and reserve pair at once — see {@link simulatePairs}.
+**/
+async function runAssetScores({ client, chainId, slots, compressor, logger }) {
+	const running = slots.filter((slot) => !slot.isShutdown);
+	const oracles = [...new Set(running.map((slot) => lower(slot.priceOracle)))];
+	const { nodes, answers, unreadableOracles } = await 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 slotsByPosition = /* @__PURE__ */ new Map();
+	for (const slot of running) {
+		const key = `${lower(slot.market)}:${lower(slot.token)}`;
+		const entry = slotsByPosition.get(key) ?? {};
+		entry[slot.reserve ? "reserve" : "main"] = slot;
+		slotsByPosition.set(key, entry);
+	}
+	const positions = [];
+	for (const { main, reserve } of slotsByPosition.values()) {
+		if (!main) continue;
+		const mainNode = nodes.get(lower(main.priceFeed));
+		if (!mainNode || mainNode.contractType === ZERO_TYPE) continue;
+		positions.push({
+			main,
+			reserve
 		});
-		const unverified = reserveFeed !== void 0 && impacts.some((impact) => !impact.identified && impact.reaches !== "both");
-		const side = (slot) => ({
-			feed: feedOf(slot),
-			name: slot.priceFeedName,
-			contractType: nodes.get(feedOf(slot))?.contractType ?? "",
-			sources: [...groupsOf(feedOf(slot)).keys()]
-		});
-		const asset = main.token.toLowerCase();
+	}
+	const { results, sourcesOf } = await simulatePairs({
+		client,
+		chainId,
+		nodes,
+		answers,
+		pairs: positions.map(({ main, reserve }) => pairOf(lower(main.priceFeed), reserve ? lower(reserve.priceFeed) : void 0, nodes)),
+		logger
+	});
+	const side = (slot) => ({
+		feed: lower(slot.priceFeed),
+		name: slot.priceFeedName,
+		contractType: nodes.get(lower(slot.priceFeed))?.contractType ?? "",
+		sources: sourcesOf(lower(slot.priceFeed))
+	});
+	const byAsset = /* @__PURE__ */ new Map();
+	positions.forEach(({ main, reserve }, i) => {
+		const result = results[i];
+		if (!result) {
+			logger?.warn(`feed ${lower(main.priceFeed)} of chain ${chainId} does not answer; ${main.tokenSymbol ?? main.token} in ${main.marketName ?? main.market} is not scored`);
+			return;
+		}
+		const asset = lower(main.token);
 		const entry = byAsset.get(asset) ?? {
 			symbol: main.tokenSymbol,
 			markets: []
@@ -145,15 +187,11 @@ async function runAssetScores({ client, chainId, slots, compressor, logger }) {
 			curatorName: main.curatorName,
 			main: side(main),
 			reserve: reserve ? side(reserve) : null,
-			hasReserve: reserveFeed !== void 0,
-			price: Number(formatUnits(before, 8)),
-			unverified,
-			notes,
-			...worstOf(impacts)
+			...result
 		});
-	}
+	});
 	return [...byAsset].map(([asset, { symbol, markets }]) => {
-		const sorted = markets.sort((a, b) => a.score - b.score);
+		const sorted = markets.sort((a, b) => b.score - a.score);
 		const worst = sorted[0] ?? null;
 		return {
 			chainId,
@@ -166,5 +204,47 @@ async function runAssetScores({ client, chainId, slots, compressor, logger }) {
 		};
 	});
 }
+/**
+* Any main feed and reserve on a chain, scored the way a market holding them
+* would be — whether or not any market does yet.
+*
+* The two trees are read off the compressor by feed rather than by oracle,
+* so a feed the curator has only just deployed scores as well as one in use.
+*
+* @throws Where there is nothing to score: the compressor cannot read a
+* feed, the main feed is a `ZeroPriceFeed`, or the final price does not
+* answer even with every pull feed under it freshened.
+**/
+async function runFeedPairScore({ client, chainId, compressor, main, reserve, logger }) {
+	const mainFeed = lower(main);
+	const reserveFeed = reserve ? lower(reserve) : void 0;
+	const feeds = reserveFeed && reserveFeed !== mainFeed ? [mainFeed, reserveFeed] : [mainFeed];
+	const { nodes, answers } = await readFeedTrees(client, compressor, feeds).catch((cause) => {
+		throw new Error(`the PriceFeedCompressor of chain ${chainId} would not read ${feeds.join(" and ")}: not a price feed it knows`, { cause });
+	});
+	for (const feed of [mainFeed, reserveFeed]) if (feed && !nodes.has(feed)) throw new Error(`feed ${feed} of chain ${chainId} is not one the PriceFeedCompressor can read`);
+	if (nodes.get(mainFeed)?.contractType === ZERO_TYPE) throw new Error(`the main feed ${mainFeed} is a ZeroPriceFeed: it prices nothing, so nothing can move`);
+	const { results, sourcesOf } = await simulatePairs({
+		client,
+		chainId,
+		nodes,
+		answers,
+		pairs: [pairOf(mainFeed, reserveFeed, nodes)],
+		logger
+	});
+	const result = results[0];
+	if (!result) throw new Error(`the main feed ${mainFeed} of chain ${chainId} does not answer, so there is no price to move`);
+	const side = (feed) => ({
+		feed,
+		name: null,
+		contractType: nodes.get(feed)?.contractType ?? "",
+		sources: sourcesOf(feed)
+	});
+	return {
+		main: side(mainFeed),
+		reserve: reserveFeed ? side(reserveFeed) : null,
+		...result
+	};
+}
 //#endregion
-export { runAssetScores };
+export { runAssetScores, runFeedPairScore };

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

@@ -1,6 +1,6 @@
 import { classifySources, sourcesByFeed } from "./classify.js";
 import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./override.js";
 import { scoreGroup, slotHarm, verdictOf } from "./score.js";
-import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest } from "./run.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readFeedTrees, readForest, readRateTargets, readUnder, runStressTest } from "./run.js";
 import "./types.js";
-export { DEFAULT_SCENARIOS, RATE_FEED_TYPE, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, groupOverride, perturb, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runStressTest, scoreGroup, slotHarm, sourcesByFeed, verdictOf };
+export { DEFAULT_SCENARIOS, RATE_FEED_TYPE, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, groupOverride, perturb, rateStub, readFeedTrees, readForest, readRateTargets, readUnder, roundDataStub, runStressTest, scoreGroup, slotHarm, sourcesByFeed, verdictOf };

package/dist/esm/permissionless/api/oracles/stress/run.js

@@ -2,7 +2,7 @@ import { priceFeedCompressorAbi } from "../../../../abi/compressors/priceFeedCom
 import { classifySources, sourcesByFeed } from "./classify.js";
 import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride } from "./override.js";
 import { scoreGroup, verdictOf } from "./score.js";
-import { formatUnits, hexToString, parseAbi } from "viem";
+import { BaseError, CallExecutionError, formatUnits, hexToString, parseAbi } from "viem";
 //#region src/permissionless/api/oracles/stress/run.ts
 /**
 * The two ends the question is asked at, which is what "infinitely large and
@@ -71,18 +71,7 @@ async function readForest(client, compressor, oracles) {
 			return;
 		}
 		const { priceFeedTree } = state.result;
-		for (const node of priceFeedTree) {
-			const address = node.baseParams.addr.toLowerCase();
-			if (nodes.has(address)) continue;
-			nodes.set(address, {
-				address,
-				contractType: typeName(node.baseParams.contractType),
-				version: Number(node.baseParams.version),
-				description: node.description,
-				underlyingFeeds: node.underlyingFeeds.map((feed) => feed.toLowerCase())
-			});
-			answers.set(address, node.answer.success ? node.answer.price : null);
-		}
+		addTree(priceFeedTree, nodes, answers);
 	});
 	return {
 		nodes,
@@ -91,6 +80,43 @@ async function readForest(client, compressor, oracles) {
 	};
 }
 /**
+* The trees under a handful of feeds, flattened, whether or not any oracle
+* holds them.
+*
+* One call for all of them: the compressor walks the feeds it is given the
+* way it walks an oracle's, and answers with the same nodes.
+*/
+async function readFeedTrees(client, compressor, feeds) {
+	const tree = await client.readContract({
+		address: compressor,
+		abi: priceFeedCompressorAbi,
+		functionName: "loadPriceFeedTree",
+		args: [feeds]
+	});
+	const nodes = /* @__PURE__ */ new Map();
+	const answers = /* @__PURE__ */ new Map();
+	addTree(tree, nodes, answers);
+	return {
+		nodes,
+		answers
+	};
+}
+/** A tree's nodes into the flattened forest, the first copy of each kept. */
+function addTree(tree, nodes, answers) {
+	for (const node of tree) {
+		const address = node.baseParams.addr.toLowerCase();
+		if (nodes.has(address)) continue;
+		nodes.set(address, {
+			address,
+			contractType: typeName(node.baseParams.contractType),
+			version: Number(node.baseParams.version),
+			description: node.description,
+			underlyingFeeds: node.underlyingFeeds.map((feed) => feed.toLowerCase())
+		});
+		answers.set(address, node.answer.success ? node.answer.price : null);
+	}
+}
+/**
 * Where each rate-bearing feed reads its rate, and what it will accept.
 *
 * The baseline a rate source is perturbed from is the feed's own `lowerBound`
@@ -152,6 +178,18 @@ async function readRateTargets(client, feeds) {
 		bounds
 	};
 }
+/** Tries after the first before a refused read is given up on. */
+const READ_RETRIES = 3;
+/**
+* A multicall failure that is the node's and not the feed's.
+*
+* A call that reverted inside the multicall is decoded from its own return
+* data and carries no error of the `eth_call` around it; a chunk the node
+* refused carries exactly that, for every call in the chunk.
+*/
+function isRefusal(error) {
+	return error instanceof BaseError && error.walk((cause) => cause instanceof CallExecutionError) !== null;
+}
 /**
 * What every feed answers with one group's sources overridden.
 *
@@ -164,7 +202,7 @@ async function readUnder(client, feeds, sources, multiplier, updatedAt, freshen
 	const driven = groupOverride(sources, multiplier, updatedAt);
 	const taken = new Set(driven.map((override) => override.address.toLowerCase()));
 	const overrides = [...groupOverride(freshen, 1, updatedAt).filter((override) => !taken.has(override.address.toLowerCase())), ...driven];
-	const results = await client.multicall({
+	const readOnce = () => client.multicall({
 		contracts: feeds.map((address) => ({
 			address,
 			abi: aggregatorAbi,
@@ -173,6 +211,17 @@ async function readUnder(client, feeds, sources, multiplier, updatedAt, freshen
 		allowFailure: true,
 		stateOverride: overrides.length > 0 ? overrides : void 0
 	});
+	let results = [];
+	for (let attempt = 0;; attempt++) {
+		results = await readOnce();
+		const refused = results.find((result) => result.status === "failure" && isRefusal(result.error));
+		if (!refused) break;
+		if (attempt >= READ_RETRIES) {
+			const reason = refused.error instanceof BaseError ? refused.error.walk().shortMessage : String(refused.error);
+			throw new Error(`the node would not answer a read of ${feeds.length} feeds after 4 tries: ${reason}`, { cause: refused.error });
+		}
+		await new Promise((resolve) => setTimeout(resolve, 500 * 2 ** attempt));
+	}
 	return new Map(feeds.map((feed, i) => {
 		const result = results[i];
 		return [feed, result?.status === "success" ? result.result[1] ?? null : null];
@@ -426,4 +475,4 @@ async function runStressTest({ client, chainId, slots, compressor, scenarios = D
 	};
 }
 //#endregion
-export { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest };
+export { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readFeedTrees, readForest, readRateTargets, readUnder, runStressTest };

package/dist/esm/permissionless/index.js

@@ -15,9 +15,9 @@ import { getFeedDecimals, getLatestPrices, getPrices } from "./utils/price-updat
 import { classifySources, sourcesByFeed } from "./api/oracles/stress/classify.js";
 import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./api/oracles/stress/override.js";
 import { scoreGroup, slotHarm, verdictOf } from "./api/oracles/stress/score.js";
-import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest } from "./api/oracles/stress/run.js";
-import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./api/oracles/score/formula.js";
-import { runAssetScores } from "./api/oracles/score/run.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readFeedTrees, readForest, readRateTargets, readUnder, runStressTest } from "./api/oracles/stress/run.js";
+import { SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./api/oracles/score/formula.js";
+import { runAssetScores, runFeedPairScore } from "./api/oracles/score/run.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./api/oracles/PermissionlessOracles.js";
 import { TokenCompressorContract } from "./bindings/compressors/token-compressor.js";
 import { WithdrawalCompressorContract } from "./bindings/compressors/withdrawal-compressor.js";
@@ -48,4 +48,4 @@ import { getBlockNumberByTimestamp } from "./utils/block-utils.js";
 import { convertQueueBatchToExecuteTx } from "./utils/governance/timelock-txs.js";
 import { getPriceUpdateTx } from "./utils/price-update/get-price-update-tx.js";
 import "./utils/index.js";
-export { AccessMode, AddressProviderContract, Addresses, ArchiveTransport, BYTECODE_REPOSITORY, BytecodeRepositoryContract, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainsNamespace, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GovernorContract, INSTANCE_MANAGER, InstanceManagerContract, InstanceOwnerTransactions, KILL_SWITCH_PROXY, KILL_SWITCH_PROXY_MINOR_VERSION, KillSwitchProxyContract, KillSwitchProxyNotAllowedError, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, PriceFeedStoreContract, RATE_FEED_TYPE, REVERT_SCORE, RoutingManagerContract, SCORE_MULTIPLIER, TOKEN_COMPRESSOR, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, UNBOUNDED_DOWN, UNBOUNDED_UP, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, classifySources, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, factorOf, finalPrice, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getFeedDecimals, getLatestPrices, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, groupOverride, handleSalt, killSwitchProxySalt, normalizeSignature, perturb, priceFeedSalt, priceFeedSetupParams, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreOfFactor, shortenHash, significantTrunc, slotHarm, sourcesByFeed, verdictOf, worstOf };
+export { AccessMode, AddressProviderContract, Addresses, ArchiveTransport, BYTECODE_REPOSITORY, BytecodeRepositoryContract, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainsNamespace, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GovernorContract, INSTANCE_MANAGER, InstanceManagerContract, InstanceOwnerTransactions, KILL_SWITCH_PROXY, KILL_SWITCH_PROXY_MINOR_VERSION, KillSwitchProxyContract, KillSwitchProxyNotAllowedError, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, PriceFeedStoreContract, RATE_FEED_TYPE, RoutingManagerContract, SCORE_MULTIPLIER, TOKEN_COMPRESSOR, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, UNBOUNDED_DOWN, UNBOUNDED_UP, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, classifySources, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, factorOf, finalPrice, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getFeedDecimals, getLatestPrices, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, groupOverride, handleSalt, killSwitchProxySalt, normalizeSignature, perturb, priceFeedSalt, priceFeedSetupParams, rateStub, readFeedTrees, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runFeedPairScore, runStressTest, scoreGroup, scoreOfFactor, shortenHash, significantTrunc, slotHarm, sourcesByFeed, verdictOf, worstOf };

package/dist/types/permissionless/api/index.d.ts

@@ -5,7 +5,7 @@ import { AttachChainsArgs, ChainScope, ChainSummaryArgs, PermissionlessChain, Pe
 import { ChainsNamespace } from "./chains/ChainsNamespace.js";
 import { DeployArgs, DeployContractArgs, DeployPriceFeedArgs, PreparedDeployment, PreparedPriceFeedDeployment } from "./deploy/types.js";
 import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./deploy/PermissionlessDeploy.js";
-import { AssetScore, AssetScoresArgs, GroupImpact, MarketScore, ScoredFeed } from "./oracles/score/types.js";
+import { AssetScore, AssetScoresArgs, FeedPairScore, FeedPairScoreArgs, GroupImpact, MarketScore, ScoredFeed } from "./oracles/score/types.js";
 import { BreakingPoint, FeedOutcome, GroupReport, GroupScenarioOutcome, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs } from "./oracles/stress/types.js";
 import { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessMarketSlot, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedDecimals, PriceFeedPrice, PriceFeedRef } from "./oracles/types.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
@@ -17,12 +17,12 @@ import "./chains/index.js";
 import { deriveEffectiveStalenessPeriod } from "./deploy/effective-staleness.js";
 import "./deploy/index.js";
 import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./errors.js";
-import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./oracles/score/formula.js";
-import { runAssetScores } from "./oracles/score/run.js";
+import { SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./oracles/score/formula.js";
+import { runAssetScores, runFeedPairScore } from "./oracles/score/run.js";
 import { TreeNode, classifySources, sourcesByFeed } from "./oracles/stress/classify.js";
 import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./oracles/stress/override.js";
-import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest } from "./oracles/stress/run.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readFeedTrees, readForest, readRateTargets, readUnder, runStressTest } from "./oracles/stress/run.js";
 import { scoreGroup, slotHarm, verdictOf } from "./oracles/stress/score.js";
 import "./oracles/index.js";
 import "./transactions/index.js";
-export { AddFeedsArgs, AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, AttachChainsArgs, BreakingPoint, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, FeedCap, FeedOutcome, ForbidFeedsArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GroupImpact, GroupReport, GroupScenarioOutcome, InstanceOwnerTransactions, InstanceTxsArgs, MarketCap, MarketScore, PermissionlessAnalytics, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessMarketSlot, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PreparedDeployment, PreparedPriceFeedDeployment, PriceChartArgs, PriceFeedArgs, PriceFeedChartPoint, PriceFeedDecimals, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedPrice, PriceFeedPriceChart, PriceFeedRef, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, RATE_FEED_TYPE, REVERT_SCORE, SCORE_MULTIPLIER, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, deriveEffectiveStalenessPeriod, factorOf, finalPrice, groupOverride, perturb, priceFeedSalt, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };
+export { AddFeedsArgs, AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, AttachChainsArgs, BreakingPoint, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, FeedCap, FeedOutcome, FeedPairScore, FeedPairScoreArgs, ForbidFeedsArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GroupImpact, GroupReport, GroupScenarioOutcome, InstanceOwnerTransactions, InstanceTxsArgs, MarketCap, MarketScore, PermissionlessAnalytics, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessMarketSlot, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PreparedDeployment, PreparedPriceFeedDeployment, PriceChartArgs, PriceFeedArgs, PriceFeedChartPoint, PriceFeedDecimals, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedPrice, PriceFeedPriceChart, PriceFeedRef, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, RATE_FEED_TYPE, SCORE_MULTIPLIER, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, deriveEffectiveStalenessPeriod, factorOf, finalPrice, groupOverride, perturb, priceFeedSalt, rateStub, readFeedTrees, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runFeedPairScore, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };

package/dist/types/permissionless/api/oracles/PermissionlessOracles.d.ts

@@ -2,7 +2,7 @@ import { PriceFeedData } from "../../../model/opportunities.js";
 import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
 import { GearboxPermissionlessOptions } from "../types.js";
 import { ChainsNamespace } from "../chains/ChainsNamespace.js";
-import { AssetScore, AssetScoresArgs } from "./score/types.js";
+import { AssetScore, AssetScoresArgs, FeedPairScore, FeedPairScoreArgs } from "./score/types.js";
 import { StressReport, StressTestArgs } from "./stress/types.js";
 import { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAssetDetails, PermissionlessAssetSummary, PermissionlessMarketSlot, PermissionlessPriceFeedDetails, PermissionlessPriceFeedStore, PriceFeedArgs, PriceFeedDecimals, PriceFeedPrice, PriceFeedRef } from "./types.js";
 //#region src/permissionless/api/oracles/PermissionlessOracles.d.ts
@@ -192,14 +192,16 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * three leaves anything to simulate.
    **/
   /**
-   * Every asset's score out of 10 for how its markets guard its price.
+   * Every asset's manipulation resistance: how far, from 1 to 10 times, a
+   * lying source can push the price its markets hold for it.
    *
    * Each source group behind an asset's feeds — Chainlink, Redstone, Lido and
-   * so on — is made in turn to answer five times what it answers now, and a
+   * so on — is made in turn to answer ten times what it answers now, and a
    * market scores by how far that moves its final price, `min(main,
-   * reserve)`: 10 for not at all, 0 for the full five times, on a log scale.
-   * A price that stops answering scores 5. An asset scores its worst running
-   * market that takes it as collateral.
+   * reserve)`, as a multiple either way: 1 for not at all, 1.04 for 4%, 10
+   * for the whole lie. A group under which the price stops answering moves
+   * nothing and is listed rather than scored. An asset scores its worst
+   * running market, underlying or collateral.
    *
    * Simulated on the chain as it stands, through state overrides in
    * `eth_call`: one call per source group per chain, so the node behind the
@@ -215,6 +217,28 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * {@link GearboxPermissionless.attach} has resolved.
    **/
   assetScores({ chainId }?: AssetScoresArgs): Promise<AssetScore[]>;
+  /**
+   * The manipulation resistance of any main feed and reserve on a chain,
+   * scored the way {@link assetScores} scores a market holding them — for
+   * trying a pair before any market does.
+   *
+   * ```ts
+   * const pair = await permissionless.oracles.feedPairScore({
+   *   chainId: 1,
+   *   main: "0x…",
+   *   reserve: "0x…",
+   * });
+   * ```
+   *
+   * Reads the chain directly, through state overrides in `eth_call`, so the
+   * client has to have attached and the node behind it has to accept them.
+   *
+   * @throws When the client has not attached, when the chain has no client or
+   * no PriceFeedCompressor, or when there is nothing to score: a feed the
+   * compressor cannot read, a `ZeroPriceFeed` main, or a final price that does
+   * not answer.
+   **/
+  feedPairScore({ chainId, main, reserve }: FeedPairScoreArgs): Promise<FeedPairScore>;
   stressTest({ chainId, ...options }: StressTestArgs): Promise<StressReport>;
   /**
    * The feeds one feed reads from, recursively.

package/dist/types/permissionless/api/oracles/index.d.ts

@@ -1,13 +1,13 @@
-import { AssetScore, AssetScoresArgs, GroupImpact, MarketScore, ScoredFeed } from "./score/types.js";
+import { AssetScore, AssetScoresArgs, FeedPairScore, FeedPairScoreArgs, GroupImpact, MarketScore, ScoredFeed } from "./score/types.js";
 import { BreakingPoint, FeedOutcome, GroupReport, GroupScenarioOutcome, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs } from "./stress/types.js";
 import { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessMarketSlot, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedDecimals, PriceFeedPrice, PriceFeedRef } from "./types.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./PermissionlessOracles.js";
-import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./score/formula.js";
-import { runAssetScores } from "./score/run.js";
+import { SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./score/formula.js";
+import { runAssetScores, runFeedPairScore } from "./score/run.js";
 import "./score/index.js";
 import { TreeNode, classifySources, sourcesByFeed } from "./stress/classify.js";
 import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./stress/override.js";
-import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest } from "./stress/run.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readFeedTrees, readForest, readRateTargets, readUnder, runStressTest } from "./stress/run.js";
 import { scoreGroup, slotHarm, verdictOf } from "./stress/score.js";
 import "./stress/index.js";
-export { AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, BreakingPoint, DEFAULT_SCENARIOS, FeedCap, FeedOutcome, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GroupImpact, GroupReport, GroupScenarioOutcome, MarketCap, MarketScore, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessMarketSlot, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedDecimals, PriceFeedPrice, PriceFeedRef, RATE_FEED_TYPE, REVERT_SCORE, SCORE_MULTIPLIER, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, factorOf, finalPrice, groupOverride, perturb, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };
+export { AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, BreakingPoint, DEFAULT_SCENARIOS, FeedCap, FeedOutcome, FeedPairScore, FeedPairScoreArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GroupImpact, GroupReport, GroupScenarioOutcome, MarketCap, MarketScore, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessMarketSlot, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedDecimals, PriceFeedPrice, PriceFeedRef, RATE_FEED_TYPE, SCORE_MULTIPLIER, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, factorOf, finalPrice, groupOverride, perturb, rateStub, readFeedTrees, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runFeedPairScore, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };