@gearbox-protocol/sdk 18.3.0 → 18.4.0

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

@@ -0,0 +1,94 @@
+import { formatUnits } from "viem";
+//#region src/permissionless/api/oracles/enrich.ts
+/**
+* What the oracles namespace works out for itself once the backend has
+* answered.
+*
+* All of it used to be the backend's, and all of it needs the chain: a quota
+* is denominated in its market's own underlying and a market cap is a supply
+* times a price, so none of these can be indexed — they can only be read at
+* the block the reader is on. Keeping them here means one description of each
+* rule rather than one per service that wants it, and a backend that holds no
+* viem client at all.
+**/
+/** Identifies a feed across chains, since an address alone does not. */
+function feedKey(chainId, address) {
+	return `${chainId}:${address.toLowerCase()}`;
+}
+/** Prices looked up the way {@link totalQuotas} and the caps need them. */
+function pricesByFeed(prices) {
+	return new Map(prices.map(({ chainId, address, price }) => [feedKey(chainId, address), price]));
+}
+/**
+* The asset's quota across its markets, totalled in USD.
+*
+* Each market's figures are converted at the price that market's own oracle
+* holds for its underlying, which is the same number that market's accounting
+* uses.
+*
+* Limits count only the markets still running, because a shut down market's
+* limit is not borrowable; what is already quoted counts everywhere, because
+* debt outstanding is exposure either way. A market whose underlying could not
+* be priced is skipped, which makes both figures floors, and `null` is nothing
+* to total rather than a zero.
+*
+* @param priceOf - The price each underlying feed reports, in the 8 decimals
+* every Gearbox feed uses.
+*/
+function totalQuotas(quotas, priceOf) {
+	let limit = 0;
+	let used = 0;
+	let anyLimit = false;
+	let anyUsed = false;
+	for (const quota of quotas) {
+		const raw = quota.underlyingPriceFeed === null ? null : priceOf(quota.underlyingPriceFeed);
+		if (raw === null || raw === void 0) continue;
+		const price = Number(formatUnits(raw, 8));
+		if (quota.quotaUsed !== null) {
+			used += quota.quotaUsed * price;
+			anyUsed = true;
+		}
+		if (quota.quotaLimit !== null && !quota.isShutdown) {
+			limit += quota.quotaLimit * price;
+			anyLimit = true;
+		}
+	}
+	return {
+		quotaLimitUsd: anyLimit ? limit : null,
+		quotaUsedUsd: anyUsed ? used : null
+	};
+}
+/**
+* What one feed values one asset's supply at: `price × totalSupply`.
+*
+* Multiplied as integers and formatted once, rather than through two floats:
+* an 8-decimal price times an 18-decimal supply loses its small end to a JS
+* number long before it loses the large one, and the figure is a total rather
+* than an estimate.
+*
+* `null` if either side could not be read — an asset nobody could price is
+* not an asset worth nothing.
+*/
+function toCap(price, totalSupply, decimals) {
+	if (price === null || price === void 0 || totalSupply === null || totalSupply === void 0) return null;
+	return formatUnits(price * totalSupply, 8 + decimals);
+}
+/** Larger first, with `null` after every figure including a real zero. */
+function descending(a, b) {
+	return (b ?? -1) - (a ?? -1);
+}
+/**
+* Assets ordered the way a reader scans them: what the protocol is built on
+* first, then what is actually borrowed against it, then what it is merely
+* allowed to be borrowed against.
+*
+* Applied here and not by the backend because the two middle terms are the
+* converted quotas, which only exist once the chain has been read. The
+* backend orders by the first term and the tie-breakers, so a caller reading
+* the route directly still gets a stable order; this refines it.
+*/
+function byCentrality(a, b) {
+	return b.underlyingMarketCount - a.underlyingMarketCount || descending(a.quotaUsedUsd, b.quotaUsedUsd) || descending(a.quotaLimitUsd, b.quotaLimitUsd) || a.symbol.localeCompare(b.symbol) || a.address.localeCompare(b.address) || a.chainId - b.chainId;
+}
+//#endregion
+export { byCentrality, feedKey, pricesByFeed, toCap, totalQuotas };

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, readFeedTrees, readForest, readRateTargets, readUnder, runStressTest } from "./stress/run.js";
+import { SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./score/formula.js";
+import { runAssetScores, runFeedPairScore } 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, SCORE_MULTIPLIER, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, factorOf, finalPrice, groupOverride, perturb, rateStub, readFeedTrees, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runFeedPairScore, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };

package/dist/esm/permissionless/api/oracles/onchain-feed.js

@@ -0,0 +1,24 @@
+import { getAddress, zeroAddress } from "viem";
+//#region src/permissionless/api/oracles/onchain-feed.ts
+/**
+* What the store would say about a feed, from what the chain says instead.
+*
+* Two fields are the store's alone and are answered as unknown rather than
+* guessed: who deployed it is a store row, so it is the zero address, and the
+* staleness period is a store setting a feed that was never added does not
+* have, so it is 0. The compressor reports `PRICE_FEED::EXTERNAL` for a
+* contract it cannot otherwise place; an empty type is the same thing said
+* less clearly.
+*/
+function onchainPriceFeed(node) {
+	return {
+		address: getAddress(node.address),
+		contractType: node.contractType.trim() || "PRICE_FEED::EXTERNAL",
+		version: node.version,
+		deployedBy: zeroAddress,
+		stalenessPeriod: 0,
+		name: node.description.trim()
+	};
+}
+//#endregion
+export { onchainPriceFeed };

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

@@ -1,4 +1,5 @@
-import { addressRecord, addressSchema } from "../schemas.js";
+import { chainSchema } from "../chains/schemas.js";
+import { addressSchema } from "../schemas.js";
 import { z } from "zod/v4";
 //#region src/permissionless/api/oracles/schemas.ts
 /**
@@ -18,100 +19,121 @@ const priceFeedSchema = z.looseObject({
 	stalenessPeriod: z.number(),
 	name: z.string()
 });
-/** {@link PermissionlessAsset} */
-const assetSchema = z.looseObject({
+/**
+* {@link PermissionlessPriceFeedAsset}
+*
+* What identifies an asset, which is all a feed's own listing of one says.
+**/
+const priceFeedAssetSchema = z.looseObject({
 	address: addressSchema,
 	symbol: z.string(),
 	name: z.string(),
-	decimals: z.number(),
+	decimals: z.number()
+});
+/** {@link PermissionlessAsset} — identified as above, plus what prices it. */
+const assetSchema = priceFeedAssetSchema.extend({
 	owner: addressSchema,
 	priceFeeds: z.array(priceFeedSchema)
 });
-/** {@link PermissionlessPriceFeedStore} */
-const priceFeedStoreSchema = z.looseObject({
-	chainId: z.number(),
-	name: z.string(),
-	isPublic: z.boolean(),
-	isActivated: z.boolean(),
-	explorerUrl: z.string(),
+/**
+* {@link PermissionlessPriceFeedStore}
+*
+* A store is a chain's, and is described by the same five fields the chain
+* list answers with, so those are extended rather than restated.
+**/
+const priceFeedStoreSchema = chainSchema.extend({
 	assets: z.array(assetSchema),
 	priceFeeds: z.array(priceFeedSchema)
 });
-/** {@link PermissionlessPrices} */
-const pricesSchema = z.looseObject({
-	prices: addressRecord(z.string().nullable()),
-	marketCaps: addressRecord(addressRecord(z.string().nullable())),
-	time: z.number()
-});
-/** {@link PermissionlessPriceFeedAsset} */
-const priceFeedAssetSchema = z.looseObject({
-	address: addressSchema,
-	symbol: z.string(),
-	name: z.string(),
-	decimals: z.number()
-});
-/** {@link PermissionlessPriceFeedMarket} */
-const priceFeedMarketSchema = z.looseObject({
+/** Every chain's {@link PermissionlessPriceFeedStore}, one per chain. */
+const priceFeedStoresSchema = z.array(priceFeedStoreSchema);
+/**
+* What names a market, whichever side it is being listed from.
+*
+* A feed's markets and an asset's markets are different reads, but they
+* answer with the same market: who curates it, what it is denominated in and
+* how much of the quota is taken. Only what the read is about differs, which
+* is what each of the two below adds.
+**/
+const marketSchema = z.looseObject({
 	market: addressSchema,
 	marketConfigurator: addressSchema,
 	curatorName: z.string().nullable(),
 	marketName: z.string().nullable(),
-	token: addressSchema,
-	tokenSymbol: z.string().nullable(),
 	underlyingSymbol: z.string().nullable(),
-	reserve: z.boolean(),
 	isUnderlying: z.boolean(),
 	quotaLimit: z.number().nullable(),
-	quotaUsed: z.number().nullable(),
-	marketStalenessPeriod: z.number().nullable()
+	quotaUsed: z.number().nullable()
+});
+/**
+* {@link PermissionlessIndexedPriceFeedMarket} — the market as the feed's slot
+* in it, before the oracle is asked what period it holds for the slot.
+**/
+const priceFeedMarketSchema = marketSchema.extend({
+	token: addressSchema,
+	tokenSymbol: z.string().nullable(),
+	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()
 });
-/** {@link PermissionlessPriceFeedDetails} */
+/** Every slot in scope, across whichever chains the read covered. */
+const marketSlotsSchema = z.array(marketSlotSchema);
+/** {@link PermissionlessIndexedPriceFeedDetails} */
 const priceFeedDetailsSchema = z.looseObject({
 	chainId: z.number(),
 	priceFeed: priceFeedSchema,
 	assets: z.array(priceFeedAssetSchema),
 	markets: z.array(priceFeedMarketSchema)
 });
-/** {@link PermissionlessPriceFeedMarketCaps} */
-const priceFeedMarketCapsSchema = z.looseObject({
-	marketCaps: addressRecord(z.string().nullable()),
-	time: z.number()
-});
 /** {@link PermissionlessAssetMarketFeed} */
 const assetMarketFeedSchema = z.looseObject({
 	address: addressSchema,
 	name: z.string().nullable(),
 	inStore: z.boolean()
 });
-/** {@link PermissionlessAssetMarket} */
-const assetMarketSchema = z.looseObject({
-	market: addressSchema,
-	marketConfigurator: addressSchema,
-	curatorName: z.string().nullable(),
-	marketName: z.string().nullable(),
+/** {@link PermissionlessAssetMarket} — the market as what prices the asset in it. */
+const assetMarketSchema = marketSchema.extend({
 	underlyingToken: addressSchema,
-	underlyingSymbol: z.string().nullable(),
-	isUnderlying: z.boolean(),
+	underlyingPriceFeed: addressSchema.nullable(),
 	isShutdown: z.boolean(),
 	mainFeed: assetMarketFeedSchema.nullable(),
-	reserveFeed: assetMarketFeedSchema.nullable(),
-	quotaLimit: z.number().nullable(),
-	quotaUsed: z.number().nullable()
+	reserveFeed: assetMarketFeedSchema.nullable()
 });
-/** {@link PermissionlessAssetDetails} */
+/** {@link PermissionlessIndexedAssetDetails} */
 const assetDetailsSchema = z.looseObject({
 	chainId: z.number(),
 	asset: priceFeedAssetSchema,
 	priceFeeds: z.array(priceFeedSchema),
-	markets: z.array(assetMarketSchema),
-	quotaLimitUsd: z.number().nullable(),
-	quotaUsedUsd: z.number().nullable()
+	markets: z.array(assetMarketSchema)
 });
-/** {@link PermissionlessAssetPrices} */
-const assetPricesSchema = z.looseObject({
-	prices: addressRecord(z.string().nullable()),
-	marketCaps: addressRecord(z.string().nullable()),
-	time: z.number()
+/** {@link PermissionlessAssetQuota} */
+const assetQuotaSchema = z.looseObject({
+	quotaLimit: z.number().nullable(),
+	quotaUsed: z.number().nullable(),
+	isShutdown: z.boolean(),
+	underlyingPriceFeed: addressSchema.nullable()
+});
+/** {@link PermissionlessIndexedAssetSummary} */
+const assetSummarySchema = z.looseObject({
+	chainId: z.number(),
+	address: addressSchema,
+	symbol: z.string(),
+	underlyingMarketCount: z.number(),
+	marketQuotas: z.array(assetQuotaSchema)
 });
+/** The list of {@link PermissionlessAssetSummary}, already ordered. */
+const assetSummariesSchema = z.array(assetSummarySchema);
 //#endregion
-export { assetDetailsSchema, assetMarketFeedSchema, assetMarketSchema, assetPricesSchema, assetSchema, priceFeedAssetSchema, priceFeedDetailsSchema, priceFeedMarketCapsSchema, priceFeedMarketSchema, priceFeedSchema, priceFeedStoreSchema, pricesSchema };
+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,51 @@
+//#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 = 10;
+/**
+* How far the final price moved, as a multiple of where it was, either way:
+* 1 for a price that did not move, 1.04 for one 4% off, and
+* {@link SCORE_MULTIPLIER} for one that took the whole lie — the most it can
+* take from one leg, and where a price over two legs of one group, moved
+* further, is held too.
+*
+* `null` for a price that stopped answering, which is not a move.
+*/
+function scoreOfFactor(factor) {
+	if (factor === null || !Number.isFinite(factor) || factor <= 0) return null;
+	const move = factor >= 1 ? factor : 1 / factor;
+	return Math.min(10, move);
+}
+/**
+* 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 furthest any group
+* moved its price. 1 where nothing moved it — no group did, or no source
+* feeds the price at all.
+*
+* A group under which the price stops answering moves nothing and does not
+* set the score; it is listed after those that do, for a reader to see.
+*/
+function worstOf(impacts) {
+	const sorted = [...impacts].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+	const worst = sorted.find((impact) => impact.score !== null) ?? null;
+	return {
+		score: worst?.score ?? 1,
+		impacts: sorted,
+		worst
+	};
+}
+//#endregion
+export { SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf };

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

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

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

@@ -0,0 +1,250 @@
+import { classifySources, sourcesByFeed } from "../stress/classify.js";
+import { RATE_FEED_TYPE, readFeedTrees, 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 lower = (address) => address.toLowerCase();
+/**
+* A main feed and the reserve a slot or a caller names for it, as the score
+* takes them: a reserve that is a `ZeroPriceFeed` is no reserve.
+*/
+function pairOf(main, reserve, nodes) {
+	const notes = [];
+	if (!reserve) {
+		notes.push("no reserve feed");
+		return {
+			main,
+			reserve: void 0,
+			notes
+		};
+	}
+	if (nodes.get(reserve)?.contractType === ZERO_TYPE) {
+		notes.push("reserve is a ZeroPriceFeed");
+		return {
+			main,
+			reserve: void 0,
+			notes
+		};
+	}
+	if (reserve === main) notes.push("reserve is the main feed");
+	return {
+		main,
+		reserve,
+		notes
+	};
+}
+/**
+* Every pair's final price under each source group lying, from one read of
+* the LP feeds' rate contracts, one of every feed as it stands, and then one
+* `eth_call` per source group with the group's sources overridden to answer
+* {@link SCORE_MULTIPLIER} times what they answer now.
+*
+* A pair whose final price does not answer as it stands comes back `null`:
+* there is no price to move.
+*/
+async function simulatePairs({ client, chainId, nodes, answers, pairs, logger }) {
+	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 roots = [...new Set(pairs.flatMap(({ main, reserve }) => reserve ? [main, reserve] : [main]))];
+	const reach = sourcesByFeed(roots, nodes, sources);
+	const sourceByTarget = new Map(sources.map((source) => [source.target, source]));
+	const drivable = (source) => source !== void 0 && source.perturbable && source.baseline !== null;
+	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 sourcesOf = (feed) => [...groupsOf(feed).keys()];
+	if (roots.length === 0) return {
+		results: [],
+		sourcesOf
+	};
+	const updatedAt = BigInt(Math.floor(Date.now() / 1e3));
+	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, 10, updatedAt) : /* @__PURE__ */ new Map(), freshRoots.length > 0 ? readUnder(client, freshRoots, members, 10, updatedAt, fresh) : /* @__PURE__ */ new Map()]);
+		return new Map([...plain, ...refreshed]);
+	};
+	const effective = pairs.map((pair) => pair.reserve && (base.get(pair.reserve) ?? null) === null ? {
+		...pair,
+		reserve: void 0,
+		notes: [...pair.notes, "reserve does not answer"]
+	} : pair);
+	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 roots) for (const group of groupsOf(root).keys()) reachedGroups.add(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) ?? []));
+	}));
+	return {
+		results: effective.map(({ main, reserve, notes }) => {
+			const before = finalPrice(base.get(main) ?? null, reserve ? base.get(reserve) ?? null : void 0);
+			if (before === null || before <= 0n) return null;
+			const onMain = groupsOf(main);
+			const onReserve = groupsOf(reserve);
+			const impacts = [.../* @__PURE__ */ new Set([...onMain.keys(), ...onReserve.keys()])].map((group) => {
+				const under = stressed.get(group) ?? /* @__PURE__ */ new Map();
+				const after = finalPrice(under.get(main) ?? null, reserve ? under.get(reserve) ?? null : void 0);
+				const factor = factorOf(before, after);
+				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,
+					score: scoreOfFactor(factor)
+				};
+			});
+			return {
+				hasReserve: reserve !== void 0,
+				price: Number(formatUnits(before, 8)),
+				unverified: reserve !== void 0 && impacts.some((impact) => !impact.identified && impact.reaches !== "both"),
+				notes,
+				...worstOf(impacts)
+			};
+		}),
+		sourcesOf
+	};
+}
+/**
+* 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, then the simulation of every market's
+* main and reserve pair at once — see {@link simulatePairs}.
+**/
+async function runAssetScores({ client, chainId, slots, compressor, logger }) {
+	const running = slots.filter((slot) => !slot.isShutdown);
+	const oracles = [...new Set(running.map((slot) => lower(slot.priceOracle)))];
+	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 slotsByPosition = /* @__PURE__ */ new Map();
+	for (const slot of running) {
+		const key = `${lower(slot.market)}:${lower(slot.token)}`;
+		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) continue;
+		const mainNode = nodes.get(lower(main.priceFeed));
+		if (!mainNode || mainNode.contractType === ZERO_TYPE) continue;
+		positions.push({
+			main,
+			reserve
+		});
+	}
+	const { results, sourcesOf } = await simulatePairs({
+		client,
+		chainId,
+		nodes,
+		answers,
+		pairs: positions.map(({ main, reserve }) => pairOf(lower(main.priceFeed), reserve ? lower(reserve.priceFeed) : void 0, nodes)),
+		logger
+	});
+	const side = (slot) => ({
+		feed: lower(slot.priceFeed),
+		name: slot.priceFeedName,
+		contractType: nodes.get(lower(slot.priceFeed))?.contractType ?? "",
+		sources: sourcesOf(lower(slot.priceFeed))
+	});
+	const byAsset = /* @__PURE__ */ new Map();
+	positions.forEach(({ main, reserve }, i) => {
+		const result = results[i];
+		if (!result) {
+			logger?.warn(`feed ${lower(main.priceFeed)} of chain ${chainId} does not answer; ${main.tokenSymbol ?? main.token} in ${main.marketName ?? main.market} is not scored`);
+			return;
+		}
+		const asset = lower(main.token);
+		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,
+			...result
+		});
+	});
+	return [...byAsset].map(([asset, { symbol, markets }]) => {
+		const sorted = markets.sort((a, b) => b.score - a.score);
+		const worst = sorted[0] ?? null;
+		return {
+			chainId,
+			asset,
+			symbol,
+			score: worst?.score ?? null,
+			unverified: sorted.some((market) => market.unverified),
+			worst,
+			markets: sorted
+		};
+	});
+}
+/**
+* Any main feed and reserve on a chain, scored the way a market holding them
+* would be — whether or not any market does yet.
+*
+* The two trees are read off the compressor by feed rather than by oracle,
+* so a feed the curator has only just deployed scores as well as one in use.
+*
+* @throws Where there is nothing to score: the compressor cannot read a
+* feed, the main feed is a `ZeroPriceFeed`, or the final price does not
+* answer even with every pull feed under it freshened.
+**/
+async function runFeedPairScore({ client, chainId, compressor, main, reserve, logger }) {
+	const mainFeed = lower(main);
+	const reserveFeed = reserve ? lower(reserve) : void 0;
+	const feeds = reserveFeed && reserveFeed !== mainFeed ? [mainFeed, reserveFeed] : [mainFeed];
+	const { nodes, answers } = await readFeedTrees(client, compressor, feeds).catch((cause) => {
+		throw new Error(`the PriceFeedCompressor of chain ${chainId} would not read ${feeds.join(" and ")}: not a price feed it knows`, { cause });
+	});
+	for (const feed of [mainFeed, reserveFeed]) if (feed && !nodes.has(feed)) throw new Error(`feed ${feed} of chain ${chainId} is not one the PriceFeedCompressor can read`);
+	if (nodes.get(mainFeed)?.contractType === ZERO_TYPE) throw new Error(`the main feed ${mainFeed} is a ZeroPriceFeed: it prices nothing, so nothing can move`);
+	const { results, sourcesOf } = await simulatePairs({
+		client,
+		chainId,
+		nodes,
+		answers,
+		pairs: [pairOf(mainFeed, reserveFeed, nodes)],
+		logger
+	});
+	const result = results[0];
+	if (!result) throw new Error(`the main feed ${mainFeed} of chain ${chainId} does not answer, so there is no price to move`);
+	const side = (feed) => ({
+		feed,
+		name: null,
+		contractType: nodes.get(feed)?.contractType ?? "",
+		sources: sourcesOf(feed)
+	});
+	return {
+		main: side(mainFeed),
+		reserve: reserveFeed ? side(reserveFeed) : null,
+		...result
+	};
+}
+//#endregion
+export { runAssetScores, runFeedPairScore };

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

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