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

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

@@ -1,73 +1,156 @@
 import { classifySources, sourcesByFeed } from "../stress/classify.js";
-import { RATE_FEED_TYPE, readForest, readRateTargets } from "../stress/run.js";
-import { scoreMarket } from "./formula.js";
+import { RATE_FEED_TYPE, 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();
 /**
-* 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 readForest(client, compressor, oracles);
+	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 { targets } = await readRateTargets(client, [...nodes.values()].filter((node) => RATE_FEED_TYPE.test(node.contractType)).map((node) => node.address));
-	const { sources } = 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 = 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 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 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 readUnder(client, roots, [], 1, updatedAt);
+	const stale = roots.filter((root) => (asIs.get(root) ?? null) === null);
+	const freshened = stale.length > 0 ? await 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 ? readUnder(client, asIsRoots, members, 5, updatedAt) : /* @__PURE__ */ new Map(), freshRoots.length > 0 ? 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 = 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 = 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 {
+				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)
+			};
+		});
+		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(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(formatUnits(before, 8)),
+			unverified,
+			notes,
+			...worstOf(impacts)
+		});
 	}
 	return [...byAsset].map(([asset, { symbol, markets }]) => {
 		const sorted = markets.sort((a, b) => a.score - b.score);

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, runStressTest } from "./run.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, 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, roundDataStub, runStressTest, scoreGroup, slotHarm, sourcesByFeed, verdictOf };
+export { DEFAULT_SCENARIOS, RATE_FEED_TYPE, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, groupOverride, perturb, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runStressTest, scoreGroup, slotHarm, sourcesByFeed, verdictOf };

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

@@ -160,8 +160,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 = groupOverride(sources, multiplier, updatedAt);
+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({
 		contracts: feeds.map((address) => ({
 			address,
@@ -424,4 +426,4 @@ async function runStressTest({ client, chainId, slots, compressor, scenarios = D
 	};
 }
 //#endregion
-export { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, runStressTest };
+export { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest };

package/dist/esm/permissionless/index.js

@@ -15,8 +15,8 @@ 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, runStressTest } from "./api/oracles/stress/run.js";
-import { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, scoreMarket } from "./api/oracles/score/formula.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 { 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";
@@ -47,4 +47,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, BOUND_WEIGHT, 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, INDEPENDENCE_WEIGHT, INSTANCE_MANAGER, InstanceManagerContract, InstanceOwnerTransactions, 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, TOKEN_COMPRESSOR, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, UNBOUNDED_DOWN, UNBOUNDED_UP, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, classifySources, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getFeedDecimals, getLatestPrices, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, groupOverride, handleSalt, normalizeSignature, perturb, priceFeedSalt, priceFeedSetupParams, rateStub, readForest, readRateTargets, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreMarket, shortenHash, significantTrunc, slotHarm, sourcesByFeed, verdictOf };
+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, 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, normalizeSignature, perturb, priceFeedSalt, priceFeedSetupParams, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, 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, MarketScore, ScoredFeed } from "./oracles/score/types.js";
+import { AssetScore, AssetScoresArgs, 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 { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, ScoreSource, scoreMarket } from "./oracles/score/formula.js";
+import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./oracles/score/formula.js";
 import { runAssetScores } 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, runStressTest } from "./oracles/stress/run.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, 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, BOUND_WEIGHT, 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, GroupReport, GroupScenarioOutcome, INDEPENDENCE_WEIGHT, 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, ScoreSource, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, deriveEffectiveStalenessPeriod, groupOverride, perturb, priceFeedSalt, rateStub, readForest, readRateTargets, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreMarket, slotHarm, sourcesByFeed, verdictOf };
+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 };

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

@@ -194,17 +194,17 @@ export declare class PermissionlessOracles 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/types/permissionless/api/oracles/index.d.ts

@@ -1,13 +1,13 @@
-import { AssetScore, AssetScoresArgs, MarketScore, ScoredFeed } from "./score/types.js";
+import { AssetScore, AssetScoresArgs, 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 { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, ScoreSource, scoreMarket } from "./score/formula.js";
+import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./score/formula.js";
 import { runAssetScores } 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, runStressTest } from "./stress/run.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, 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, BOUND_WEIGHT, BreakingPoint, DEFAULT_SCENARIOS, FeedCap, FeedOutcome, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GroupReport, GroupScenarioOutcome, INDEPENDENCE_WEIGHT, 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, ScoreSource, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, groupOverride, perturb, rateStub, readForest, readRateTargets, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreMarket, slotHarm, sourcesByFeed, verdictOf };
+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 };

package/dist/types/permissionless/api/oracles/score/formula.d.ts

@@ -1,46 +1,39 @@
-import { MarketScore, ScoredFeed } from "./types.js";
+import { GroupImpact } from "./types.js";
 //#region src/permissionless/api/oracles/score/formula.d.ts
+/** What every source of a group is made to answer, as a multiple of now. */
+export declare 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.
  */
-export declare const INDEPENDENCE_WEIGHT = 6;
-export declare const BOUND_WEIGHT = 5;
-/** A source, as the overlap between two feeds is counted. */
-export interface ScoreSource {
-  /** What two feeds have to share to be on the same source. */
-  key: string;
-  /** What a reader is told. */
-  name: string;
-  /** A source the classifier named, rather than one grouped alone. */
-  identified: boolean;
-}
+export declare const REVERT_SCORE = 5;
 /**
- * One market's score for one asset.
+ * 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.
  *
- * `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.
+ * A bound holding a price within a few percent keeps a 10; a price that let
+ * half the lie through, ×√5, scores 5.
+ */
+export declare function scoreOfFactor(factor: number | null): number;
+/**
+ * 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.
+ */
+export declare function finalPrice(main: bigint | null, reserve: bigint | null | undefined): bigint | null;
+/** `stressed / base` as a float, `null` where the stressed price is gone. */
+export declare function factorOf(base: bigint, stressed: bigint | null): number | null;
+/**
+ * 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.
  */
-export declare function scoreMarket(market: Omit<MarketScore, "main" | "reserve" | "hasReserve" | "independence" | "bounded" | "sharedSources" | "unverified" | "score" | "reasons">, main: {
-  feed: Omit<ScoredFeed, "sources">;
-  sources: ScoreSource[];
-}, reserve: {
-  feed: Omit<ScoredFeed, "sources">;
-  sources: ScoreSource[];
-} | null): MarketScore;
+export declare function worstOf(impacts: GroupImpact[]): {
+  score: number;
+  impacts: GroupImpact[];
+  worst: GroupImpact | null;
+};
 //#endregion

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

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

package/dist/types/permissionless/api/oracles/score/run.d.ts

@@ -3,11 +3,14 @@ import { PermissionlessMarketSlot } from "../types.js";
 import { Address, Chain, PublicClient, Transport } from "viem";
 //#region src/permissionless/api/oracles/score/run.d.ts
 /**
- * Every asset of one chain, scored by how its running markets price it.
+ * 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 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.
  **/
 export declare function runAssetScores({ client, chainId, slots, compressor, logger }: {
   client: PublicClient<Transport, Chain>;

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

@@ -10,16 +10,47 @@ export interface ScoredFeed {
   /** Gearbox contract type of the feed itself, `""` for one it never deployed. */
   contractType: string;
   /**
-   * Every price source beneath the feed, by name: `"Chainlink"`, `"Lido"`, or
-   * the description of a source nothing could name.
+   * Every source group beneath the feed: `"Chainlink"`, `"Lido"`, or the
+   * description of a source nothing could name.
    */
   sources: string[];
 }
+/**
+ * What one source group, lying, does to the price a market holds for an
+ * asset.
+ **/
+export interface GroupImpact {
+  group: string;
+  /** The group was recognised rather than inferred from one feed's name. */
+  identified: boolean;
+  /**
+   * The group's sources this market's feeds read, by what they say they are:
+   * `"stETH / ETH"`, `"ETH / USD"`.
+   */
+  feeds: string[];
+  /** Which of the market's feeds read the group. */
+  reaches: "main" | "reserve" | "both";
+  /**
+   * The final price under the lie over the final price now, in USD. `null` is
+   * a price that stopped answering.
+   */
+  factor: number | null;
+  /**
+   * The same, against the market's own underlying: what an account is
+   * valued by. A lie that moves collateral and underlying alike leaves it at
+   * 1. `null` where either price stopped answering.
+   */
+  ratioFactor: number | null;
+  /** 0 to 10, by {@link scoreOfFactor}. */
+  score: number;
+}
 /**
  * How well one market guards one asset's price, out of 10.
  *
- * `score = max(0, 10 − 6·(1 − independence) − 5·(1 − bounded))`, rounded down
- * to a half point.
+ * Every source group behind the asset's feeds is made, one group at a time,
+ * to answer {@link SCORE_MULTIPLIER} times what it answers now. The market
+ * scores by the group that moves its final price — `min(main, reserve)` —
+ * the furthest.
  **/
 export interface MarketScore {
   market: Address;
@@ -30,31 +61,28 @@ export interface MarketScore {
   /** `null` where the market holds no reserve for the asset at all. */
   reserve: ScoredFeed | null;
   /**
-   * The reserve is a second feed: present, not a `ZeroPriceFeed`, and not
-   * the main feed again.
+   * The final price is `min(main, reserve)`: a reserve is present, is not a
+   * `ZeroPriceFeed`, and answers. Where it is not, the final price is the
+   * main feed's alone.
    */
   hasReserve: boolean;
+  /** The final price now, in USD. */
+  price: number;
+  /** Every group behind the two feeds, the most damaging first. */
+  impacts: GroupImpact[];
+  /** The group the score comes from; `null` where no source feeds the price. */
+  worst: GroupImpact | null;
   /**
-   * The share of the two feeds' sources they do not have in common:
-   * `1 − |shared| / |all|`. 1 for feeds with nothing in common, 0 for feeds
-   * on the same sources — and 0 where {@link hasReserve} is false.
-   */
-  independence: number;
-  /** Main or reserve is a `BoundedPriceFeed` or a Gearbox LP feed. */
-  bounded: boolean;
-  /** The sources the two feeds have in common, by name. */
-  sharedSources: string[];
-  /**
-   * The independence counted here rests on a source nothing could name.
+   * The score rests on a source nothing could name.
    *
-   * Such a source counts as its own, so two of them look independent even
-   * if one operator stands behind both. The same unnamed source on both
-   * sides — the same contract — is still counted as shared.
+   * Such a source is a group of its own and is perturbed alone, so where one
+   * feed reads it and the other does not, the other is taken to hold — which
+   * it would not if one operator stood behind both.
    */
   unverified: boolean;
   score: number;
-  /** What cost the market its points, for a reader to act on. Empty at 10. */
-  reasons: string[];
+  /** How the market is set up, where that explains its score. */
+  notes: string[];
 }
 /**
  * One asset's score: its worst market's.

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

@@ -1,6 +1,6 @@
 import { BreakingPoint, FeedOutcome, GroupReport, GroupScenarioOutcome, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs } from "./types.js";
 import { TreeNode, classifySources, sourcesByFeed } from "./classify.js";
 import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./override.js";
-import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, runStressTest } from "./run.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest } from "./run.js";
 import { scoreGroup, slotHarm, verdictOf } from "./score.js";
-export { BreakingPoint, DEFAULT_SCENARIOS, FeedOutcome, GroupReport, GroupScenarioOutcome, RATE_FEED_TYPE, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, groupOverride, perturb, rateStub, readForest, readRateTargets, roundDataStub, runStressTest, scoreGroup, slotHarm, sourcesByFeed, verdictOf };
+export { BreakingPoint, DEFAULT_SCENARIOS, FeedOutcome, GroupReport, GroupScenarioOutcome, RATE_FEED_TYPE, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, groupOverride, perturb, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runStressTest, scoreGroup, slotHarm, sourcesByFeed, verdictOf };

package/dist/types/permissionless/api/oracles/stress/run.d.ts

@@ -1,4 +1,4 @@
-import { StressReport, StressScenario } from "./types.js";
+import { StressReport, StressScenario, StressSource } from "./types.js";
 import { PermissionlessMarketSlot } from "../types.js";
 import { TreeNode } from "./classify.js";
 import { Address, Chain, PublicClient, Transport } from "viem";
@@ -49,6 +49,22 @@ export declare function readRateTargets(client: PublicClient<Transport, Chain>,
     upper: bigint;
   }>;
 }>;
+/**
+ * What every feed answers with one group's sources overridden.
+ *
+ * One `eth_call` for the whole chain: the overrides go in once and the feeds
+ * are read through a multicall inside them, so a group costs a round trip per
+ * scenario rather than a round trip per feed. A feed that reverts comes back
+ * `null`, which is an outcome and not an error.
+ */
+export declare function readUnder(client: PublicClient<Transport, Chain>, feeds: Address[], sources: StressSource[], multiplier: number, updatedAt: bigint,
+/**
+ * Sources re-answered as they stand, under a fresh timestamp: a pull feed
+ * nobody has pushed to lately is stale, and a feed over it reverts on that
+ * before anything about the price is learnt. `sources` win where the two
+ * overlap.
+ */
+freshen?: StressSource[]): Promise<Map<Address, bigint | null>>;
 /**
  * Every source behind one chain's markets, put through the sweep a group at a
  * time.