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

package/dist/cjs/permissionless/utils/price-update/get-prices.js

@@ -32,6 +32,16 @@ const latestRoundDataAbi = [{
 	stateMutability: "view",
 	type: "function"
 }];
+const decimalsAbi = [{
+	inputs: [],
+	name: "decimals",
+	outputs: [{
+		name: "",
+		type: "uint8"
+	}],
+	stateMutability: "view",
+	type: "function"
+}];
 function getLatestRoundDataCall(priceFeed) {
 	return {
 		address: priceFeed,
@@ -41,6 +51,34 @@ function getLatestRoundDataCall(priceFeed) {
 	};
 }
 /**
+* The scale each feed's answer is in, in one multicall.
+*
+* Part of the Chainlink interface every feed in a Gearbox tree implements,
+* and the only way to read an answer that is not an oracle's own: a feed an
+* oracle holds reports 8 decimals by construction, while the feeds beneath a
+* composite are whatever was deployed — an ETH/USD aggregator at 8 and a
+* rate leg at 18 sit under the same parent.
+*
+* `null` is a feed that would not answer, which a caller should treat as
+* unknown rather than defaulting it to 8.
+*/
+async function getFeedDecimals({ client, priceFeeds }) {
+	if (priceFeeds.length === 0) return {};
+	const results = await client.multicall({
+		contracts: priceFeeds.map((priceFeed) => ({
+			address: priceFeed,
+			abi: decimalsAbi,
+			functionName: "decimals",
+			args: []
+		})),
+		allowFailure: true
+	});
+	return Object.fromEntries(priceFeeds.map((priceFeed, index) => {
+		const result = results[index];
+		return [priceFeed, result?.status === "success" ? Number(result.result) : null];
+	}));
+}
+/**
 * What the feeds report as they stand, in one multicall.
 *
 * What {@link getPrices} does without the part that makes it expensive: no
@@ -107,5 +145,6 @@ async function getPrices({ client, priceFeeds, chunkSize = 10, gasLimit }) {
 	}), {});
 }
 //#endregion
+exports.getFeedDecimals = getFeedDecimals;
 exports.getLatestPrices = getLatestPrices;
 exports.getPrices = getPrices;

package/dist/cjs/permissionless/utils/price-update/index.js

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_permissionless_utils_price_update_get_prices = require("./get-prices.js");
 const require_permissionless_utils_price_update_get_updatable_feeds = require("./get-updatable-feeds.js");
 const require_permissionless_utils_price_update_get_price_update_tx = require("./get-price-update-tx.js");
+exports.getFeedDecimals = require_permissionless_utils_price_update_get_prices.getFeedDecimals;
 exports.getLatestPrices = require_permissionless_utils_price_update_get_prices.getLatestPrices;
 exports.getPriceUpdateTx = require_permissionless_utils_price_update_get_price_update_tx.getPriceUpdateTx;
 exports.getPrices = require_permissionless_utils_price_update_get_prices.getPrices;

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

@@ -6,10 +6,16 @@ import "./chains/index.js";
 import { deriveEffectiveStalenessPeriod } from "./deploy/effective-staleness.js";
 import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./deploy/PermissionlessDeploy.js";
 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 { 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";
 import { GearboxPermissionless } from "./GearboxPermissionless.js";
 import "./oracles/index.js";
 import "./transactions/index.js";
 import "./types.js";
-export { ChainsNamespace, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, InstanceOwnerTransactions, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };
+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 };

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

@@ -6,9 +6,11 @@ import "../../../onchain/index.js";
 import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
 import "../../deployment/addresses.js";
 import { AddressProviderContract } from "../../bindings/address-provider.js";
-import { getLatestPrices, getPrices } from "../../utils/price-update/get-prices.js";
+import { getFeedDecimals, getLatestPrices, getPrices } from "../../utils/price-update/get-prices.js";
 import { byCentrality, feedKey, pricesByFeed, toCap, totalQuotas } from "./enrich.js";
-import { assetDetailsSchema, assetSummariesSchema, priceFeedDetailsSchema, priceFeedStoresSchema } from "./schemas.js";
+import { assetDetailsSchema, assetSummariesSchema, marketSlotsSchema, priceFeedDetailsSchema, priceFeedStoresSchema } from "./schemas.js";
+import { runStressTest } from "./stress/run.js";
+import { runAssetScores } from "./score/run.js";
 import { erc20Abi } from "viem";
 //#region src/permissionless/api/oracles/PermissionlessOracles.ts
 const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = { 143: 100000000n };
@@ -93,6 +95,31 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 		});
 	}
 	/**
+	* 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: marketSlotsSchema
+		});
+	}
+	/**
 	* One feed of the store: what it is, which assets it may price, and which
 	* market slots it currently fills.
 	*
@@ -289,6 +316,111 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 		}).sort(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.
+	*
+	* 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
+	* 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 AddressProviderContract("0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38", client).getLatestVersionAddress(AP_PRICE_FEED_COMPRESSOR);
+				return await 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 AddressProviderContract("0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38", client).getLatestVersionAddress(AP_PRICE_FEED_COMPRESSOR);
+		return 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
@@ -353,6 +485,65 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 			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 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/esm/permissionless/api/oracles/index.js

@@ -1,2 +1,11 @@
-export { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./PermissionlessOracles.js";
+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 { 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 };

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

@@ -75,6 +75,21 @@ const priceFeedMarketSchema = marketSchema.extend({
 	reserve: z.boolean(),
 	priceOracle: 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: z.number(),
+	underlyingToken: addressSchema,
+	isShutdown: z.boolean(),
+	priceFeed: addressSchema,
+	priceFeedName: z.string().nullable(),
+	priceFeedInStore: z.boolean(),
+	underlyingPriceFeed: addressSchema.nullable()
+});
+/** Every slot in scope, across whichever chains the read covered. */
+const marketSlotsSchema = z.array(marketSlotSchema);
 /** {@link PermissionlessIndexedPriceFeedDetails} */
 const priceFeedDetailsSchema = z.looseObject({
 	chainId: z.number(),
@@ -121,4 +136,4 @@ const assetSummarySchema = z.looseObject({
 /** The list of {@link PermissionlessAssetSummary}, already ordered. */
 const assetSummariesSchema = z.array(assetSummarySchema);
 //#endregion
-export { assetDetailsSchema, assetMarketFeedSchema, assetMarketSchema, assetQuotaSchema, assetSchema, assetSummariesSchema, assetSummarySchema, priceFeedAssetSchema, priceFeedDetailsSchema, priceFeedMarketSchema, priceFeedSchema, priceFeedStoreSchema, priceFeedStoresSchema };
+export { assetDetailsSchema, assetMarketFeedSchema, assetMarketSchema, assetQuotaSchema, assetSchema, assetSummariesSchema, assetSummarySchema, marketSlotSchema, marketSlotsSchema, priceFeedAssetSchema, priceFeedDetailsSchema, priceFeedMarketSchema, priceFeedSchema, priceFeedStoreSchema, priceFeedStoresSchema };

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

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

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

@@ -0,0 +1,4 @@
+import { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, scoreMarket } from "./formula.js";
+import { runAssetScores } from "./run.js";
+import "./types.js";
+export { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, runAssetScores, scoreMarket };

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

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

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

@@ -0,0 +1 @@
+export {};