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

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

@@ -0,0 +1,99 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let viem = require("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((0, viem.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 (0, viem.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
+exports.byCentrality = byCentrality;
+exports.feedKey = feedKey;
+exports.pricesByFeed = pricesByFeed;
+exports.toCap = toCap;
+exports.totalQuotas = totalQuotas;

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

@@ -1,6 +1,34 @@
 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.BOUND_WEIGHT = require_permissionless_api_oracles_score_formula.BOUND_WEIGHT;
+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.INDEPENDENCE_WEIGHT = require_permissionless_api_oracles_score_formula.INDEPENDENCE_WEIGHT;
 exports.PermissionlessOracles = require_permissionless_api_oracles_PermissionlessOracles.PermissionlessOracles;
+exports.RATE_FEED_TYPE = require_permissionless_api_oracles_stress_run.RATE_FEED_TYPE;
+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.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.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.scoreMarket = require_permissionless_api_oracles_score_formula.scoreMarket;
+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;

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

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_chains_schemas = require("../chains/schemas.js");
 const require_permissionless_api_schemas = require("../schemas.js");
 let zod_v4 = require("zod/v4");
 //#region src/permissionless/api/oracles/schemas.ts
@@ -19,69 +20,135 @@ const priceFeedSchema = zod_v4.z.looseObject({
 	stalenessPeriod: zod_v4.z.number(),
 	name: zod_v4.z.string()
 });
-/** {@link PermissionlessAsset} */
-const assetSchema = zod_v4.z.looseObject({
+/**
+* {@link PermissionlessPriceFeedAsset}
+*
+* What identifies an asset, which is all a feed's own listing of one says.
+**/
+const priceFeedAssetSchema = zod_v4.z.looseObject({
 	address: require_permissionless_api_schemas.addressSchema,
 	symbol: zod_v4.z.string(),
 	name: zod_v4.z.string(),
-	decimals: zod_v4.z.number(),
+	decimals: zod_v4.z.number()
+});
+/** {@link PermissionlessAsset} — identified as above, plus what prices it. */
+const assetSchema = priceFeedAssetSchema.extend({
 	owner: require_permissionless_api_schemas.addressSchema,
 	priceFeeds: zod_v4.z.array(priceFeedSchema)
 });
-/** {@link PermissionlessPriceFeedStore} */
-const priceFeedStoreSchema = zod_v4.z.looseObject({
-	chainId: zod_v4.z.number(),
-	name: zod_v4.z.string(),
-	isPublic: zod_v4.z.boolean(),
-	isActivated: zod_v4.z.boolean(),
-	explorerUrl: zod_v4.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 = require_permissionless_api_chains_schemas.chainSchema.extend({
 	assets: zod_v4.z.array(assetSchema),
 	priceFeeds: zod_v4.z.array(priceFeedSchema)
 });
-/** {@link PermissionlessPrices} */
-const pricesSchema = zod_v4.z.looseObject({
-	prices: require_permissionless_api_schemas.addressRecord(zod_v4.z.string().nullable()),
-	marketCaps: require_permissionless_api_schemas.addressRecord(require_permissionless_api_schemas.addressRecord(zod_v4.z.string().nullable())),
-	time: zod_v4.z.number()
-});
-/** {@link PermissionlessPriceFeedAsset} */
-const priceFeedAssetSchema = zod_v4.z.looseObject({
-	address: require_permissionless_api_schemas.addressSchema,
-	symbol: zod_v4.z.string(),
-	name: zod_v4.z.string(),
-	decimals: zod_v4.z.number()
-});
-/** {@link PermissionlessPriceFeedMarket} */
-const priceFeedMarketSchema = zod_v4.z.looseObject({
+/** Every chain's {@link PermissionlessPriceFeedStore}, one per chain. */
+const priceFeedStoresSchema = zod_v4.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 = zod_v4.z.looseObject({
 	market: require_permissionless_api_schemas.addressSchema,
 	marketConfigurator: require_permissionless_api_schemas.addressSchema,
 	curatorName: zod_v4.z.string().nullable(),
 	marketName: zod_v4.z.string().nullable(),
+	underlyingSymbol: zod_v4.z.string().nullable(),
+	isUnderlying: zod_v4.z.boolean(),
+	quotaLimit: zod_v4.z.number().nullable(),
+	quotaUsed: zod_v4.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: require_permissionless_api_schemas.addressSchema,
 	tokenSymbol: zod_v4.z.string().nullable(),
-	underlyingSymbol: zod_v4.z.string().nullable(),
 	reserve: zod_v4.z.boolean(),
-	isUnderlying: zod_v4.z.boolean(),
-	quotaLimit: zod_v4.z.number().nullable()
+	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()
 });
-/** {@link PermissionlessPriceFeedDetails} */
+/** 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(),
 	priceFeed: priceFeedSchema,
 	assets: zod_v4.z.array(priceFeedAssetSchema),
 	markets: zod_v4.z.array(priceFeedMarketSchema)
 });
-/** {@link PermissionlessPriceFeedMarketCaps} */
-const priceFeedMarketCapsSchema = zod_v4.z.looseObject({
-	marketCaps: require_permissionless_api_schemas.addressRecord(zod_v4.z.string().nullable()),
-	time: zod_v4.z.number()
+/** {@link PermissionlessAssetMarketFeed} */
+const assetMarketFeedSchema = zod_v4.z.looseObject({
+	address: require_permissionless_api_schemas.addressSchema,
+	name: zod_v4.z.string().nullable(),
+	inStore: zod_v4.z.boolean()
+});
+/** {@link PermissionlessAssetMarket} — the market as what prices the asset in it. */
+const assetMarketSchema = marketSchema.extend({
+	underlyingToken: require_permissionless_api_schemas.addressSchema,
+	underlyingPriceFeed: require_permissionless_api_schemas.addressSchema.nullable(),
+	isShutdown: zod_v4.z.boolean(),
+	mainFeed: assetMarketFeedSchema.nullable(),
+	reserveFeed: assetMarketFeedSchema.nullable()
+});
+/** {@link PermissionlessIndexedAssetDetails} */
+const assetDetailsSchema = zod_v4.z.looseObject({
+	chainId: zod_v4.z.number(),
+	asset: priceFeedAssetSchema,
+	priceFeeds: zod_v4.z.array(priceFeedSchema),
+	markets: zod_v4.z.array(assetMarketSchema)
+});
+/** {@link PermissionlessAssetQuota} */
+const assetQuotaSchema = zod_v4.z.looseObject({
+	quotaLimit: zod_v4.z.number().nullable(),
+	quotaUsed: zod_v4.z.number().nullable(),
+	isShutdown: zod_v4.z.boolean(),
+	underlyingPriceFeed: require_permissionless_api_schemas.addressSchema.nullable()
+});
+/** {@link PermissionlessIndexedAssetSummary} */
+const assetSummarySchema = zod_v4.z.looseObject({
+	chainId: zod_v4.z.number(),
+	address: require_permissionless_api_schemas.addressSchema,
+	symbol: zod_v4.z.string(),
+	underlyingMarketCount: zod_v4.z.number(),
+	marketQuotas: zod_v4.z.array(assetQuotaSchema)
 });
+/** The list of {@link PermissionlessAssetSummary}, already ordered. */
+const assetSummariesSchema = zod_v4.z.array(assetSummarySchema);
 //#endregion
+exports.assetDetailsSchema = assetDetailsSchema;
+exports.assetMarketFeedSchema = assetMarketFeedSchema;
+exports.assetMarketSchema = assetMarketSchema;
+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.priceFeedMarketCapsSchema = priceFeedMarketCapsSchema;
 exports.priceFeedMarketSchema = priceFeedMarketSchema;
 exports.priceFeedSchema = priceFeedSchema;
 exports.priceFeedStoreSchema = priceFeedStoreSchema;
-exports.pricesSchema = pricesSchema;
+exports.priceFeedStoresSchema = priceFeedStoresSchema;

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

@@ -0,0 +1,99 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.BOUND_WEIGHT = BOUND_WEIGHT;
+exports.INDEPENDENCE_WEIGHT = INDEPENDENCE_WEIGHT;
+exports.scoreMarket = scoreMarket;

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

@@ -0,0 +1,8 @@
+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.BOUND_WEIGHT = require_permissionless_api_oracles_score_formula.BOUND_WEIGHT;
+exports.INDEPENDENCE_WEIGHT = require_permissionless_api_oracles_score_formula.INDEPENDENCE_WEIGHT;
+exports.runAssetScores = require_permissionless_api_oracles_score_run.runAssetScores;
+exports.scoreMarket = require_permissionless_api_oracles_score_formula.scoreMarket;

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

@@ -0,0 +1,88 @@
+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");
+//#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 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 } = 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 } = require_permissionless_api_oracles_stress_classify.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 = require_permissionless_api_oracles_stress_classify.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(require_permissionless_api_oracles_score_formula.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
+exports.runAssetScores = runAssetScores;

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

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