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

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, readUnder, runStressTest } from "./oracles/stress/run.js";
+import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./oracles/score/formula.js";
+import { runAssetScores } from "./oracles/score/run.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
 import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransactions.js";
 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 { ChainsNamespace, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, InstanceOwnerTransactions, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, RATE_FEED_TYPE, REVERT_SCORE, SCORE_MULTIPLIER, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, deriveEffectiveStalenessPeriod, factorOf, finalPrice, groupOverride, perturb, priceFeedSalt, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };

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

@@ -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.
+	*
+	* 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 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, readUnder, runStressTest } from "./stress/run.js";
+import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./score/formula.js";
+import { runAssetScores } from "./score/run.js";
+import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./PermissionlessOracles.js";
+import "./score/index.js";
+import "./stress/index.js";
 import "./types.js";
+export { DEFAULT_SCENARIOS, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles, RATE_FEED_TYPE, REVERT_SCORE, SCORE_MULTIPLIER, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, factorOf, finalPrice, groupOverride, perturb, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };

package/dist/esm/permissionless/api/oracles/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,55 @@
+//#region src/permissionless/api/oracles/score/formula.ts
+/** What every source of a group is made to answer, as a multiple of now. */
+const SCORE_MULTIPLIER = 5;
+/**
+* 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
+export { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf };

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

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

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

@@ -0,0 +1,170 @@
+import { classifySources, sourcesByFeed } from "../stress/classify.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();
+/**
+* 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 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 readRateTargets(client, [...nodes.values()].filter((node) => RATE_FEED_TYPE.test(node.contractType)).map((node) => node.address));
+	const { sources, unresolved } = classifySources(chainId, [...nodes.values()], targets, (target) => rateBaselines.get(target) ?? answers.get(target) ?? null);
+	for (const node of unresolved) logger?.warn(`feed ${node.address} of chain ${chainId} would not say what it reads its rate from; its protocol is not perturbed`);
+	const slotsByPosition = /* @__PURE__ */ new Map();
+	for (const slot of running) {
+		const key = `${slot.market.toLowerCase()}:${slot.token.toLowerCase()}`;
+		const entry = slotsByPosition.get(key) ?? {};
+		entry[slot.reserve ? "reserve" : "main"] = slot;
+		slotsByPosition.set(key, entry);
+	}
+	const positions = [];
+	for (const { main, reserve } of slotsByPosition.values()) {
+		if (!main || main.isUnderlying) continue;
+		const mainNode = nodes.get(feedOf(main));
+		if (!mainNode || mainNode.contractType === ZERO_TYPE) continue;
+		const notes = [];
+		let reserveFeed;
+		if (!reserve) notes.push("no reserve feed");
+		else if (nodes.get(feedOf(reserve))?.contractType === ZERO_TYPE) notes.push("reserve is a ZeroPriceFeed");
+		else {
+			reserveFeed = feedOf(reserve);
+			if (reserveFeed === feedOf(main)) notes.push("reserve is the main feed");
+		}
+		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);
+		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(formatUnits(before, 8)),
+			unverified,
+			notes,
+			...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
+export { runAssetScores };

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

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