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

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

@@ -7,6 +7,12 @@ require("./chains/index.js");
 const require_permissionless_api_deploy_effective_staleness = require("./deploy/effective-staleness.js");
 const require_permissionless_api_deploy_PermissionlessDeploy = require("./deploy/PermissionlessDeploy.js");
 require("./deploy/index.js");
+const require_permissionless_api_oracles_stress_classify = require("./oracles/stress/classify.js");
+const require_permissionless_api_oracles_stress_override = require("./oracles/stress/override.js");
+const require_permissionless_api_oracles_stress_score = require("./oracles/stress/score.js");
+const require_permissionless_api_oracles_stress_run = require("./oracles/stress/run.js");
+const require_permissionless_api_oracles_score_formula = require("./oracles/score/formula.js");
+const require_permissionless_api_oracles_score_run = require("./oracles/score/run.js");
 const require_permissionless_api_oracles_PermissionlessOracles = require("./oracles/PermissionlessOracles.js");
 const require_permissionless_api_transactions_InstanceOwnerTransactions = require("./transactions/InstanceOwnerTransactions.js");
 const require_permissionless_api_GearboxPermissionless = require("./GearboxPermissionless.js");
@@ -15,6 +21,7 @@ require("./transactions/index.js");
 require("./types.js");
 exports.ChainsNamespace = require_permissionless_api_chains_ChainsNamespace.ChainsNamespace;
 exports.DEFAULT_DEPLOY_SALT = require_permissionless_api_deploy_PermissionlessDeploy.DEFAULT_DEPLOY_SALT;
+exports.DEFAULT_SCENARIOS = require_permissionless_api_oracles_stress_run.DEFAULT_SCENARIOS;
 exports.GET_PRICES_CHUNK_SIZE = require_permissionless_api_oracles_PermissionlessOracles.GET_PRICES_CHUNK_SIZE;
 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;
@@ -27,5 +34,28 @@ exports.PermissionlessOracles = require_permissionless_api_oracles_Permissionles
 exports.PriceFeedNotInStoreError = require_permissionless_api_errors.PriceFeedNotInStoreError;
 exports.PriceFeedSaltMissingError = require_permissionless_api_errors.PriceFeedSaltMissingError;
 exports.PriceFeedStalenessUnknownError = require_permissionless_api_errors.PriceFeedStalenessUnknownError;
+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.SCORE_MULTIPLIER = require_permissionless_api_oracles_score_formula.SCORE_MULTIPLIER;
+exports.UNBOUNDED_DOWN = require_permissionless_api_oracles_stress_override.UNBOUNDED_DOWN;
+exports.UNBOUNDED_UP = require_permissionless_api_oracles_stress_override.UNBOUNDED_UP;
+exports.classifySources = require_permissionless_api_oracles_stress_classify.classifySources;
 exports.deriveEffectiveStalenessPeriod = require_permissionless_api_deploy_effective_staleness.deriveEffectiveStalenessPeriod;
+exports.factorOf = require_permissionless_api_oracles_score_formula.factorOf;
+exports.finalPrice = require_permissionless_api_oracles_score_formula.finalPrice;
+exports.groupOverride = require_permissionless_api_oracles_stress_override.groupOverride;
+exports.perturb = require_permissionless_api_oracles_stress_override.perturb;
 exports.priceFeedSalt = require_permissionless_api_deploy_PermissionlessDeploy.priceFeedSalt;
+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.scoreOfFactor = require_permissionless_api_oracles_score_formula.scoreOfFactor;
+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/cjs/permissionless/api/oracles/PermissionlessOracles.js

@@ -10,6 +10,8 @@ const require_permissionless_bindings_address_provider = require("../../bindings
 const require_permissionless_utils_price_update_get_prices = require("../../utils/price-update/get-prices.js");
 const require_permissionless_api_oracles_enrich = require("./enrich.js");
 const require_permissionless_api_oracles_schemas = require("./schemas.js");
+const require_permissionless_api_oracles_stress_run = require("./stress/run.js");
+const require_permissionless_api_oracles_score_run = require("./score/run.js");
 let viem = require("viem");
 //#region src/permissionless/api/oracles/PermissionlessOracles.ts
 const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = { 143: 100000000n };
@@ -94,6 +96,31 @@ var PermissionlessOracles = class extends require_offchain_AbstractOffchainNames
 		});
 	}
 	/**
+	* Every market slot in force, with the feed holding it and what the market
+	* has riding on it.
+	*
+	* The chain's whole slot table, which {@link feed} and {@link asset} answer
+	* one subject's slice of. What reads it this way is analysis over every
+	* market at once — which feed holds which slot, and what breaks if it
+	* lies — and asking a feed at a time would be a few hundred requests for
+	* the same rows.
+	*
+	* Served as indexed, with nothing folded in: the quotas are in each
+	* market's own underlying, as everywhere else, and pricing them is
+	* {@link getPrices} over the `underlyingPriceFeed` column.
+	*
+	* ```ts
+	* const slots = await permissionless.oracles.slots({ chainId: 1 });
+	* ```
+	**/
+	async slots({ chainId } = {}) {
+		return this.getData({
+			path: "/pfs/slots",
+			query: { chainId: chainId?.toString() },
+			schema: require_permissionless_api_oracles_schemas.marketSlotsSchema
+		});
+	}
+	/**
 	* One feed of the store: what it is, which assets it may price, and which
 	* market slots it currently fills.
 	*
@@ -290,6 +317,111 @@ var PermissionlessOracles = class extends require_offchain_AbstractOffchainNames
 		}).sort(require_permissionless_api_oracles_enrich.byCentrality);
 	}
 	/**
+	* What each source of price information can do to the chain's markets if it
+	* lies.
+	*
+	* The feeds under a chain's oracles are partitioned by where their numbers
+	* actually come from — Chainlink, Redstone, Pyth, Lido, Curve, each vault's
+	* own issuer — on the grounds that a source fails as a whole: whoever
+	* trusts one Chainlink aggregator trusts the operator behind all of them.
+	* Each group is then made to report a multiple of what it reports now, and
+	* every feed the markets read is read again inside that same call.
+	*
+	* No fork and no harness. The lie is a state override on an `eth_call`, so
+	* the composite feeds above it, their bounds and the oracle's own checks all
+	* run as deployed, against real state, at the current block — what comes
+	* back is what the market would have read.
+	*
+	* Each slot is scored by how its collateral moved *against its market's own
+	* underlying*, because that is what an account is valued by: a group that
+	* moves both legs has moved nothing. Beyond the two unbounded ends, each
+	* group is bisected for the multiple at which something first breaks, which
+	* is the figure that separates a source held in check by a bound from one
+	* nothing is checking.
+	*
+	* ```ts
+	* const report = await permissionless.oracles.stressTest({ chainId: 1 });
+	* for (const group of report.groups) {
+	*   console.log(group.verdict);
+	* }
+	* ```
+	*
+	* Report {@link StressReport.unidentifiedUsd} alongside anything taken from
+	* this: it is the quota priced through a source the partition could only
+	* name after its own description, and nothing says what that fails with.
+	*
+	* Reads the chain directly, so the client has to have attached — see
+	* {@link GearboxPermissionless.attach}. Costs one request for the slots and
+	* then, per group, one `eth_call` per scenario plus the bisection's; a whole
+	* chain comes to a minute or so, and `thresholds: false` cuts it to seconds.
+	*
+	* @throws When the client has not attached, when the chain has no client
+	* configured, or when no PriceFeedCompressor is deployed on it — none of the
+	* three leaves anything to simulate.
+	**/
+	/**
+	* Every asset's score out of 10 for how its markets guard its price.
+	*
+	* 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
+	* const scores = await permissionless.oracles.assetScores({ chainId: 1 });
+	* ```
+	*
+	* @throws {PermissionlessNotAttachedError} before
+	* {@link GearboxPermissionless.attach} has resolved.
+	**/
+	async assetScores({ chainId } = {}) {
+		const slots = await this.slots({ chainId });
+		const byChain = /* @__PURE__ */ new Map();
+		for (const slot of slots) byChain.set(slot.chainId, [...byChain.get(slot.chainId) ?? [], slot]);
+		return (await Promise.all([...byChain].map(async ([id, chainSlots]) => {
+			let client;
+			try {
+				client = this.#chains.client(id);
+			} catch (e) {
+				this.logger?.warn(`chain ${id} has no client, leaving its assets unscored: ${describe(e)}`);
+				return [];
+			}
+			try {
+				const compressor = await new require_permissionless_bindings_address_provider.AddressProviderContract("0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38", client).getLatestVersionAddress(require_onchain_constants_address_provider.AP_PRICE_FEED_COMPRESSOR);
+				return await require_permissionless_api_oracles_score_run.runAssetScores({
+					client,
+					chainId: id,
+					slots: chainSlots,
+					compressor,
+					logger: this.logger ?? void 0
+				});
+			} catch (e) {
+				this.logger?.warn(`chain ${id} would not report its feed trees, leaving its assets unscored: ${describe(e)}`);
+				return [];
+			}
+		}))).flat();
+	}
+	async stressTest({ chainId, ...options }) {
+		const client = this.#chains.client(chainId);
+		const compressor = await new require_permissionless_bindings_address_provider.AddressProviderContract("0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38", client).getLatestVersionAddress(require_onchain_constants_address_provider.AP_PRICE_FEED_COMPRESSOR);
+		return require_permissionless_api_oracles_stress_run.runStressTest({
+			client,
+			chainId,
+			compressor,
+			slots: await this.slots({ chainId }),
+			logger: this.logger ?? void 0,
+			...options
+		});
+	}
+	/**
 	* The feeds one feed reads from, recursively.
 	*
 	* Answers for any feed the chain has indexed, store member or not: a
@@ -354,6 +486,65 @@ var PermissionlessOracles = class extends require_offchain_AbstractOffchainNames
 			price: prices.get(chainId)?.[address.toLowerCase()] ?? null
 		}));
 	}
+	/**
+	* The scale each of the named feeds answers in.
+	*
+	* The companion to {@link getPrices} for the callers whose feeds are not
+	* all an oracle's: everything an oracle holds reports 8 decimals, but the
+	* feeds under a composite are whatever was deployed, and a rate leg at 18
+	* read as 8 is wrong by ten orders of magnitude rather than visibly wrong.
+	*
+	* Separate from the price because the two keep different company: this is
+	* fixed for the life of the contract and worth caching for the session,
+	* while a price is re-read whenever the reader asks. One multicall per
+	* chain either way.
+	*
+	* `null` is a feed that would not answer, or one on a chain with no client
+	* configured.
+	*
+	* ```ts
+	* const [{ decimals }] = await permissionless.oracles.getDecimals([
+	*   { chainId: 1, address: feed },
+	* ]);
+	* ```
+	*
+	* @returns One entry per feed asked for, in the order asked.
+	**/
+	async getDecimals(feeds) {
+		const byChain = /* @__PURE__ */ new Map();
+		for (const { chainId, address } of feeds) {
+			const addresses = byChain.get(chainId) ?? /* @__PURE__ */ new Set();
+			addresses.add(address.toLowerCase());
+			byChain.set(chainId, addresses);
+		}
+		const chainIds = [...byChain.keys()];
+		const results = await Promise.all(chainIds.map((chainId) => this.#decimalsOf(chainId, [...byChain.get(chainId) ?? []])));
+		const decimals = new Map(chainIds.map((id, i) => [id, results[i] ?? {}]));
+		return feeds.map(({ chainId, address }) => ({
+			chainId,
+			address,
+			decimals: decimals.get(chainId)?.[address.toLowerCase()] ?? null
+		}));
+	}
+	/** One chain's half of {@link getDecimals}. */
+	async #decimalsOf(chainId, priceFeeds) {
+		let client;
+		try {
+			client = this.#chains.client(chainId);
+		} catch (e) {
+			this.logger?.warn(`chain ${chainId} has no client, reporting its ${priceFeeds.length} feed(s) without a scale: ${describe(e)}`);
+			return {};
+		}
+		try {
+			return await require_permissionless_utils_price_update_get_prices.getFeedDecimals({
+				client,
+				priceFeeds
+			});
+		} catch (e) {
+			this.logger?.warn(`chain ${chainId} would not answer decimals for its ${priceFeeds.length} feed(s): ${describe(e)}`);
+			return {};
+		}
+	}
 	/** One chain's half of {@link getPrices}: the cheap pass, then the rest. */
 	async #pricesOf(chainId, priceFeeds) {
 		let client;

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

@@ -1,6 +1,38 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_oracles_stress_classify = require("./stress/classify.js");
+const require_permissionless_api_oracles_stress_override = require("./stress/override.js");
+const require_permissionless_api_oracles_stress_score = require("./stress/score.js");
+const require_permissionless_api_oracles_stress_run = require("./stress/run.js");
+const require_permissionless_api_oracles_score_formula = require("./score/formula.js");
+const require_permissionless_api_oracles_score_run = require("./score/run.js");
 const require_permissionless_api_oracles_PermissionlessOracles = require("./PermissionlessOracles.js");
+require("./score/index.js");
+require("./stress/index.js");
 require("./types.js");
+exports.DEFAULT_SCENARIOS = require_permissionless_api_oracles_stress_run.DEFAULT_SCENARIOS;
 exports.GET_PRICES_CHUNK_SIZE = require_permissionless_api_oracles_PermissionlessOracles.GET_PRICES_CHUNK_SIZE;
 exports.GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = require_permissionless_api_oracles_PermissionlessOracles.GET_PRICES_GAS_LIMIT_BY_CHAIN_ID;
 exports.PermissionlessOracles = require_permissionless_api_oracles_PermissionlessOracles.PermissionlessOracles;
+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.SCORE_MULTIPLIER = require_permissionless_api_oracles_score_formula.SCORE_MULTIPLIER;
+exports.UNBOUNDED_DOWN = require_permissionless_api_oracles_stress_override.UNBOUNDED_DOWN;
+exports.UNBOUNDED_UP = require_permissionless_api_oracles_stress_override.UNBOUNDED_UP;
+exports.classifySources = require_permissionless_api_oracles_stress_classify.classifySources;
+exports.factorOf = require_permissionless_api_oracles_score_formula.factorOf;
+exports.finalPrice = require_permissionless_api_oracles_score_formula.finalPrice;
+exports.groupOverride = require_permissionless_api_oracles_stress_override.groupOverride;
+exports.perturb = require_permissionless_api_oracles_stress_override.perturb;
+exports.rateStub = require_permissionless_api_oracles_stress_override.rateStub;
+exports.readForest = require_permissionless_api_oracles_stress_run.readForest;
+exports.readRateTargets = require_permissionless_api_oracles_stress_run.readRateTargets;
+exports.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.scoreOfFactor = require_permissionless_api_oracles_score_formula.scoreOfFactor;
+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/cjs/permissionless/api/oracles/schemas.js

@@ -76,6 +76,21 @@ const priceFeedMarketSchema = marketSchema.extend({
 	reserve: zod_v4.z.boolean(),
 	priceOracle: require_permissionless_api_schemas.addressSchema
 });
+/**
+* {@link PermissionlessMarketSlot} — the same slot read from the chain's end,
+* so the feed is a column rather than what was asked for.
+**/
+const marketSlotSchema = priceFeedMarketSchema.extend({
+	chainId: zod_v4.z.number(),
+	underlyingToken: require_permissionless_api_schemas.addressSchema,
+	isShutdown: zod_v4.z.boolean(),
+	priceFeed: require_permissionless_api_schemas.addressSchema,
+	priceFeedName: zod_v4.z.string().nullable(),
+	priceFeedInStore: zod_v4.z.boolean(),
+	underlyingPriceFeed: require_permissionless_api_schemas.addressSchema.nullable()
+});
+/** Every slot in scope, across whichever chains the read covered. */
+const marketSlotsSchema = zod_v4.z.array(marketSlotSchema);
 /** {@link PermissionlessIndexedPriceFeedDetails} */
 const priceFeedDetailsSchema = zod_v4.z.looseObject({
 	chainId: zod_v4.z.number(),
@@ -129,6 +144,8 @@ exports.assetQuotaSchema = assetQuotaSchema;
 exports.assetSchema = assetSchema;
 exports.assetSummariesSchema = assetSummariesSchema;
 exports.assetSummarySchema = assetSummarySchema;
+exports.marketSlotSchema = marketSlotSchema;
+exports.marketSlotsSchema = marketSlotsSchema;
 exports.priceFeedAssetSchema = priceFeedAssetSchema;
 exports.priceFeedDetailsSchema = priceFeedDetailsSchema;
 exports.priceFeedMarketSchema = priceFeedMarketSchema;

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

@@ -0,0 +1,61 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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;
+/**
+* The score of a price that stops answering under the lie.
+*
+* Half marks: nobody can borrow against a wrong number, but nobody can be
+* liquidated either until the feed is replaced.
+*/
+const REVERT_SCORE = 5;
+/**
+* 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.
+*/
+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 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 finalPrice(main, reserve) {
+	if (main === null || reserve === null) return null;
+	if (reserve === void 0) return main;
+	return main < reserve ? main : reserve;
+}
+/** `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);
+}
+/**
+* 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 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 {
+		score: worst?.score ?? 10,
+		impacts: sorted,
+		worst
+	};
+}
+//#endregion
+exports.REVERT_SCORE = REVERT_SCORE;
+exports.SCORE_MULTIPLIER = SCORE_MULTIPLIER;
+exports.factorOf = factorOf;
+exports.finalPrice = finalPrice;
+exports.scoreOfFactor = scoreOfFactor;
+exports.worstOf = worstOf;

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

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_oracles_score_formula = require("./formula.js");
+const require_permissionless_api_oracles_score_run = require("./run.js");
+require("./types.js");
+exports.REVERT_SCORE = require_permissionless_api_oracles_score_formula.REVERT_SCORE;
+exports.SCORE_MULTIPLIER = require_permissionless_api_oracles_score_formula.SCORE_MULTIPLIER;
+exports.factorOf = require_permissionless_api_oracles_score_formula.factorOf;
+exports.finalPrice = require_permissionless_api_oracles_score_formula.finalPrice;
+exports.runAssetScores = require_permissionless_api_oracles_score_run.runAssetScores;
+exports.scoreOfFactor = require_permissionless_api_oracles_score_formula.scoreOfFactor;
+exports.worstOf = require_permissionless_api_oracles_score_formula.worstOf;

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

@@ -0,0 +1,171 @@
+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();
+/**
+* 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, 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 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, 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 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");
+		}
+		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);
+		entry.markets.push({
+			market: main.market,
+			marketName: main.marketName,
+			marketConfigurator: main.marketConfigurator,
+			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);
+		const worst = sorted[0] ?? null;
+		return {
+			chainId,
+			asset,
+			symbol,
+			score: worst?.score ?? null,
+			unverified: sorted.some((market) => market.unverified),
+			worst,
+			markets: sorted
+		};
+	});
+}
+//#endregion
+exports.runAssetScores = runAssetScores;

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

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