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

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

@@ -2,73 +2,156 @@ 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");
+let viem = require("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();
 /**
-* How a source is told apart from another when two feeds are compared.
+* 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 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.
+* 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, unreadableOracles } = await require_permissionless_api_oracles_stress_run.readForest(client, compressor, oracles);
+	const { nodes, answers, 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();
+	const { targets, baselines: rateBaselines } = 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, unresolved } = require_permissionless_api_oracles_stress_classify.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 position = positions.get(key) ?? {};
-		position[slot.reserve ? "reserve" : "main"] = slot;
-		positions.set(key, position);
+		const entry = slotsByPosition.get(key) ?? {};
+		entry[slot.reserve ? "reserve" : "main"] = slot;
+		slotsByPosition.set(key, entry);
 	}
-	const byAsset = /* @__PURE__ */ new Map();
-	for (const { main, reserve } of positions.values()) {
+	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");
+		}
+		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)])];
+	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 require_permissionless_api_oracles_stress_run.readUnder(client, roots, [], 1, updatedAt);
+	const stale = roots.filter((root) => (asIs.get(root) ?? null) === null);
+	const freshened = stale.length > 0 ? await require_permissionless_api_oracles_stress_run.readUnder(client, stale, [], 1, updatedAt, fresh) : /* @__PURE__ */ new Map();
+	const base = new Map(roots.map((root) => [root, asIs.get(root) ?? freshened.get(root) ?? null]));
+	const asIsRoots = roots.filter((root) => (asIs.get(root) ?? null) !== null);
+	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 ? require_permissionless_api_oracles_stress_run.readUnder(client, asIsRoots, members, 5, updatedAt) : /* @__PURE__ */ new Map(), freshRoots.length > 0 ? require_permissionless_api_oracles_stress_run.readUnder(client, freshRoots, members, 5, 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 = require_permissionless_api_oracles_stress_classify.sourcesByFeed(roots, nodes, sources);
+	const sourceByTarget = new Map(sources.map((source) => [source.target, source]));
+	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);
+	}
+	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 = require_permissionless_api_oracles_score_formula.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 = require_permissionless_api_oracles_score_formula.finalPrice(under.get(mainFeed) ?? null, reserveFeed ? under.get(reserveFeed) ?? null : void 0);
+			const factor = require_permissionless_api_oracles_score_formula.factorOf(before, after);
+			const underlying = underlyingOf(main);
+			const debtBefore = underlying ? base.get(underlying) ?? null : null;
+			const debtFactor = debtBefore === null || debtBefore <= 0n || !underlying ? null : require_permissionless_api_oracles_score_formula.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 {
+				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: require_permissionless_api_oracles_score_formula.scoreOfFactor(factor)
+			};
+		});
+		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 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({
+		entry.markets.push({
 			market: main.market,
 			marketName: main.marketName,
 			marketConfigurator: main.marketConfigurator,
-			curatorName: main.curatorName
-		}, side(main), reserve ? side(reserve) : null));
+			curatorName: main.curatorName,
+			main: side(main),
+			reserve: reserve ? side(reserve) : null,
+			hasReserve: reserveFeed !== void 0,
+			price: Number((0, viem.formatUnits)(before, 8)),
+			unverified,
+			notes,
+			...require_permissionless_api_oracles_score_formula.worstOf(impacts)
+		});
 	}
 	return [...byAsset].map(([asset, { symbol, markets }]) => {
 		const sorted = markets.sort((a, b) => a.score - b.score);

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

@@ -14,6 +14,7 @@ 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.readUnder = require_permissionless_api_oracles_stress_run.readUnder;
 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;

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

@@ -161,8 +161,10 @@ async function readRateTargets(client, feeds) {
 * scenario rather than a round trip per feed. A feed that reverts comes back
 * `null`, which is an outcome and not an error.
 */
-async function readUnder(client, feeds, sources, multiplier, updatedAt) {
-	const overrides = require_permissionless_api_oracles_stress_override.groupOverride(sources, multiplier, updatedAt);
+async function readUnder(client, feeds, sources, multiplier, updatedAt, freshen = []) {
+	const driven = require_permissionless_api_oracles_stress_override.groupOverride(sources, multiplier, updatedAt);
+	const taken = new Set(driven.map((override) => override.address.toLowerCase()));
+	const overrides = [...require_permissionless_api_oracles_stress_override.groupOverride(freshen, 1, updatedAt).filter((override) => !taken.has(override.address.toLowerCase())), ...driven];
 	const results = await client.multicall({
 		contracts: feeds.map((address) => ({
 			address,
@@ -429,4 +431,5 @@ exports.DEFAULT_SCENARIOS = DEFAULT_SCENARIOS;
 exports.RATE_FEED_TYPE = RATE_FEED_TYPE;
 exports.readForest = readForest;
 exports.readRateTargets = readRateTargets;
+exports.readUnder = readUnder;
 exports.runStressTest = runStressTest;

package/dist/cjs/permissionless/index.js

@@ -52,7 +52,6 @@ exports.AccessMode = require_permissionless_bindings_types.AccessMode;
 exports.AddressProviderContract = require_permissionless_bindings_address_provider.AddressProviderContract;
 exports.Addresses = require_permissionless_deployment_addresses.Addresses;
 exports.ArchiveTransport = require_permissionless_chains_archive_transport.ArchiveTransport;
-exports.BOUND_WEIGHT = require_permissionless_api_oracles_score_formula.BOUND_WEIGHT;
 exports.BYTECODE_REPOSITORY = require_permissionless_utils_literals.BYTECODE_REPOSITORY;
 exports.BytecodeRepositoryContract = require_permissionless_bindings_bytecode_repository.BytecodeRepositoryContract;
 exports.CROSS_CHAIN_GOVERNANCE = require_permissionless_utils_literals.CROSS_CHAIN_GOVERNANCE;
@@ -65,7 +64,6 @@ exports.GET_PRICES_CHUNK_SIZE = require_permissionless_api_oracles_Permissionles
 exports.GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = require_permissionless_api_oracles_PermissionlessOracles.GET_PRICES_GAS_LIMIT_BY_CHAIN_ID;
 exports.GearboxPermissionless = require_permissionless_api_GearboxPermissionless.GearboxPermissionless;
 exports.GovernorContract = require_permissionless_bindings_governance_governor.GovernorContract;
-exports.INDEPENDENCE_WEIGHT = require_permissionless_api_oracles_score_formula.INDEPENDENCE_WEIGHT;
 exports.INSTANCE_MANAGER = require_permissionless_utils_literals.INSTANCE_MANAGER;
 exports.InstanceManagerContract = require_permissionless_bindings_instance_manager.InstanceManagerContract;
 exports.InstanceOwnerTransactions = require_permissionless_api_transactions_InstanceOwnerTransactions.InstanceOwnerTransactions;
@@ -88,7 +86,9 @@ exports.PriceFeedSaltMissingError = require_permissionless_api_errors.PriceFeedS
 exports.PriceFeedStalenessUnknownError = require_permissionless_api_errors.PriceFeedStalenessUnknownError;
 exports.PriceFeedStoreContract = require_permissionless_bindings_price_feed_store.PriceFeedStoreContract;
 exports.RATE_FEED_TYPE = require_permissionless_api_oracles_stress_run.RATE_FEED_TYPE;
+exports.REVERT_SCORE = require_permissionless_api_oracles_score_formula.REVERT_SCORE;
 exports.RoutingManagerContract = require_permissionless_bindings_router_routing_manager.RoutingManagerContract;
+exports.SCORE_MULTIPLIER = require_permissionless_api_oracles_score_formula.SCORE_MULTIPLIER;
 exports.TOKEN_COMPRESSOR = require_permissionless_utils_literals.TOKEN_COMPRESSOR;
 exports.TimeLockContract = require_permissionless_bindings_governance_timelock.TimeLockContract;
 exports.TokenCompressorContract = require_permissionless_bindings_compressors_token_compressor.TokenCompressorContract;
@@ -110,6 +110,8 @@ exports.deepJsonParse = require_permissionless_utils_format.deepJsonParse;
 exports.deployUsingPublicCreate2 = require_permissionless_utils_create2.deployUsingPublicCreate2;
 exports.deriveEffectiveStalenessPeriod = require_permissionless_api_deploy_effective_staleness.deriveEffectiveStalenessPeriod;
 exports.encodeFunctionParams = require_permissionless_utils_abi_encoder.encodeFunctionParams;
+exports.factorOf = require_permissionless_api_oracles_score_formula.factorOf;
+exports.finalPrice = require_permissionless_api_oracles_score_formula.finalPrice;
 exports.formatBytecodeSize = require_permissionless_utils_format.formatBytecodeSize;
 exports.formatBytecodeVersion = require_permissionless_utils_format.formatBytecodeVersion;
 exports.getBlockNumberByTimestamp = require_permissionless_utils_block_utils.getBlockNumberByTimestamp;
@@ -131,13 +133,15 @@ exports.priceFeedSetupParams = require_permissionless_bindings_pricefeeds_index.
 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.readUnder = require_permissionless_api_oracles_stress_run.readUnder;
 exports.roundDataStub = require_permissionless_api_oracles_stress_override.roundDataStub;
 exports.runAssetScores = require_permissionless_api_oracles_score_run.runAssetScores;
 exports.runStressTest = require_permissionless_api_oracles_stress_run.runStressTest;
 exports.scoreGroup = require_permissionless_api_oracles_stress_score.scoreGroup;
-exports.scoreMarket = require_permissionless_api_oracles_score_formula.scoreMarket;
+exports.scoreOfFactor = require_permissionless_api_oracles_score_formula.scoreOfFactor;
 exports.shortenHash = require_permissionless_utils_format.shortenHash;
 exports.significantTrunc = require_permissionless_utils_format.significantTrunc;
 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;
+exports.worstOf = require_permissionless_api_oracles_score_formula.worstOf;

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

@@ -9,8 +9,8 @@ import "./deploy/index.js";
 import { classifySources, sourcesByFeed } from "./oracles/stress/classify.js";
 import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./oracles/stress/override.js";
 import { scoreGroup, slotHarm, verdictOf } from "./oracles/stress/score.js";
-import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, runStressTest } from "./oracles/stress/run.js";
-import { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, scoreMarket } from "./oracles/score/formula.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest } from "./oracles/stress/run.js";
+import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./oracles/score/formula.js";
 import { runAssetScores } from "./oracles/score/run.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
 import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransactions.js";
@@ -18,4 +18,4 @@ import { GearboxPermissionless } from "./GearboxPermissionless.js";
 import "./oracles/index.js";
 import "./transactions/index.js";
 import "./types.js";
-export { BOUND_WEIGHT, ChainsNamespace, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, INDEPENDENCE_WEIGHT, InstanceOwnerTransactions, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, RATE_FEED_TYPE, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, deriveEffectiveStalenessPeriod, groupOverride, perturb, priceFeedSalt, rateStub, readForest, readRateTargets, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreMarket, slotHarm, sourcesByFeed, verdictOf };
+export { ChainsNamespace, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, InstanceOwnerTransactions, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, RATE_FEED_TYPE, REVERT_SCORE, SCORE_MULTIPLIER, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, deriveEffectiveStalenessPeriod, factorOf, finalPrice, groupOverride, perturb, priceFeedSalt, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };

package/dist/esm/permissionless/api/oracles/PermissionlessOracles.js

@@ -361,17 +361,17 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 	/**
 	* Every asset's score out of 10 for how its markets guard its price.
 	*
-	* A market scores 10 when its reserve feed is a second feed on other
-	* sources than the main one, and one of the two is bounded — a
-	* `BoundedPriceFeed` or a Gearbox LP feed. It loses 6 points as the two
-	* feeds' sources overlap — all of them if there is no reserve, it is a
-	* `ZeroPriceFeed`, or it is the main feed again — and 5 if neither is
-	* bounded. An asset scores its worst running market that takes it as
-	* collateral.
-	*
-	* Read off the chain, one multicall of feed trees per chain, so the score
-	* is of the trees as they stand rather than as last indexed. A chain with
-	* no client configured is left out with a warning rather than failing the
+	* 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
+	* 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.
+	*
+	* 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
+	* client has to accept overrides. A chain with no client configured, or
+	* whose node refuses, is left out with a warning rather than failing the
 	* rest.
 	*
 	* ```ts

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

@@ -1,11 +1,11 @@
 import { classifySources, sourcesByFeed } from "./stress/classify.js";
 import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./stress/override.js";
 import { scoreGroup, slotHarm, verdictOf } from "./stress/score.js";
-import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, runStressTest } from "./stress/run.js";
-import { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, scoreMarket } from "./score/formula.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest } from "./stress/run.js";
+import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./score/formula.js";
 import { runAssetScores } from "./score/run.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./PermissionlessOracles.js";
 import "./score/index.js";
 import "./stress/index.js";
 import "./types.js";
-export { BOUND_WEIGHT, DEFAULT_SCENARIOS, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, INDEPENDENCE_WEIGHT, PermissionlessOracles, RATE_FEED_TYPE, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, groupOverride, perturb, rateStub, readForest, readRateTargets, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreMarket, slotHarm, sourcesByFeed, verdictOf };
+export { DEFAULT_SCENARIOS, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles, RATE_FEED_TYPE, REVERT_SCORE, SCORE_MULTIPLIER, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, factorOf, finalPrice, groupOverride, perturb, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };

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

@@ -1,96 +1,55 @@
 //#region src/permissionless/api/oracles/score/formula.ts
+/** What every source of a group is made to answer, as a multiple of now. */
+const SCORE_MULTIPLIER = 5;
 /**
-* How well a market guards an asset's price, from its two feeds alone.
+* The score of a price that stops answering under the lie.
 *
-* 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.
+* Half marks: nobody can borrow against a wrong number, but nobody can be
+* liquidated either until the feed is replaced.
 */
-const INDEPENDENCE_WEIGHT = 6;
-const BOUND_WEIGHT = 5;
+const REVERT_SCORE = 5;
 /**
-* The feed types that bound what they answer: the `BoundedPriceFeed`, and
-* every Gearbox LP feed, all of which clamp the rate they read.
+* 0 to 10 by how far the final price moved, on a log scale against the lie
+* itself: 10 for a price that did not move, 0 for one that moved by the full
+* {@link SCORE_MULTIPLIER} or more, either way. Rounded to a half point.
+*
+* A bound holding a price within a few percent keeps a 10; a price that let
+* half the lie through, ×√5, scores 5.
 */
-const BOUNDED_TYPE = /::(BOUNDED|ERC4626|CURVE_\w+|WSTETH|YEARN|MELLOW\w*|BALANCER\w*)$/;
-const ZERO_TYPE = "PRICE_FEED::ZERO";
+function scoreOfFactor(factor) {
+	if (factor === null || !Number.isFinite(factor) || factor <= 0) return 5;
+	const moved = Math.abs(Math.log(factor)) / Math.log(5);
+	return Math.round(10 * Math.max(0, 1 - moved) * 2) / 2;
+}
 /**
-* 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.
+* The price a market settles on: the lower of main and reserve, or the main
+* feed's alone where there is no reserve to compare it with. `null` where a
+* feed it needs does not answer.
 */
-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;
+function finalPrice(main, reserve) {
+	if (main === null || reserve === null) return null;
+	if (reserve === void 0) return main;
+	return main < reserve ? main : reserve;
 }
-/** 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;
+/** `stressed / base` as a float, `null` where the stressed price is gone. */
+function factorOf(base, stressed) {
+	if (stressed === null) return null;
+	return Number(stressed) / Number(base);
 }
 /**
-* 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.
+* The market's score and the group it comes from: the lowest of its groups,
+* ties going to the group that moved the price further. 10 where no source
+* feeds the price at all, since nothing can be made to lie about it.
 */
-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)));
+function worstOf(impacts) {
+	const distance = (impact) => impact.factor === null ? Infinity : Math.abs(Math.log(impact.factor));
+	const sorted = [...impacts].sort((a, b) => a.score - b.score || distance(b) - distance(a));
+	const worst = sorted[0] ?? null;
 	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
+		score: worst?.score ?? 10,
+		impacts: sorted,
+		worst
 	};
 }
 //#endregion
-export { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, scoreMarket };
+export { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf };

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

@@ -1,4 +1,4 @@
-import { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, scoreMarket } from "./formula.js";
+import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./formula.js";
 import { runAssetScores } from "./run.js";
 import "./types.js";
-export { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, runAssetScores, scoreMarket };
+export { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, runAssetScores, scoreOfFactor, worstOf };