@gearbox-protocol/sdk 18.3.0 → 18.4.0

package/dist/types/permissionless/api/oracles/onchain-feed.d.ts

@@ -0,0 +1,15 @@
+import { PriceFeed } from "../../core/pricefeed.js";
+import { TreeNode } from "./stress/classify.js";
+//#region src/permissionless/api/oracles/onchain-feed.d.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.
+ */
+export declare function onchainPriceFeed(node: TreeNode): PriceFeed;
+//#endregion

package/dist/types/permissionless/api/oracles/schemas.d.ts

@@ -17,7 +17,18 @@ export declare const priceFeedSchema: z.ZodObject<{
   stalenessPeriod: z.ZodNumber;
   name: z.ZodString;
 }, z.core.$loose>;
-/** {@link PermissionlessAsset} */
+/**
+ * {@link PermissionlessPriceFeedAsset}
+ *
+ * What identifies an asset, which is all a feed's own listing of one says.
+ **/
+export declare const priceFeedAssetSchema: z.ZodObject<{
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  symbol: z.ZodString;
+  name: z.ZodString;
+  decimals: z.ZodNumber;
+}, z.core.$loose>;
+/** {@link PermissionlessAsset} — identified as above, plus what prices it. */
 export declare const assetSchema: z.ZodObject<{
   address: z.ZodCustom<`0x${string}`, `0x${string}`>;
   symbol: z.ZodString;
@@ -33,7 +44,12 @@ export declare const assetSchema: z.ZodObject<{
     name: z.ZodString;
   }, z.core.$loose>>;
 }, z.core.$loose>;
-/** {@link PermissionlessPriceFeedStore} */
+/**
+ * {@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.
+ **/
 export declare const priceFeedStoreSchema: z.ZodObject<{
   chainId: z.ZodNumber;
   name: z.ZodString;
@@ -64,35 +80,103 @@ export declare const priceFeedStoreSchema: z.ZodObject<{
     name: z.ZodString;
   }, z.core.$loose>>;
 }, z.core.$loose>;
-/** {@link PermissionlessPrices} */
-export declare const pricesSchema: z.ZodObject<{
-  prices: z.ZodType<Record<`0x${string}`, string | null>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, string | null>, unknown>>;
-  marketCaps: z.ZodType<Record<`0x${string}`, Record<`0x${string}`, string | null>>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, Record<`0x${string}`, string | null>>, unknown>>;
-  time: z.ZodNumber;
-}, z.core.$loose>;
-/** {@link PermissionlessPriceFeedAsset} */
-export declare const priceFeedAssetSchema: z.ZodObject<{
-  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
-  symbol: z.ZodString;
+/** Every chain's {@link PermissionlessPriceFeedStore}, one per chain. */
+export declare const priceFeedStoresSchema: z.ZodArray<z.ZodObject<{
+  chainId: z.ZodNumber;
   name: z.ZodString;
-  decimals: z.ZodNumber;
-}, z.core.$loose>;
-/** {@link PermissionlessPriceFeedMarket} */
+  isPublic: z.ZodBoolean;
+  isActivated: z.ZodBoolean;
+  explorerUrl: z.ZodString;
+  assets: z.ZodArray<z.ZodObject<{
+    address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    owner: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    priceFeeds: z.ZodArray<z.ZodObject<{
+      address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+      contractType: z.ZodString;
+      version: z.ZodNumber;
+      deployedBy: z.ZodCustom<`0x${string}`, `0x${string}`>;
+      stalenessPeriod: z.ZodNumber;
+      name: z.ZodString;
+    }, z.core.$loose>>;
+  }, z.core.$loose>>;
+  priceFeeds: z.ZodArray<z.ZodObject<{
+    address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    contractType: z.ZodString;
+    version: z.ZodNumber;
+    deployedBy: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    stalenessPeriod: z.ZodNumber;
+    name: z.ZodString;
+  }, z.core.$loose>>;
+}, z.core.$loose>>;
+/**
+ * {@link PermissionlessIndexedPriceFeedMarket} — the market as the feed's slot
+ * in it, before the oracle is asked what period it holds for the slot.
+ **/
 export declare const priceFeedMarketSchema: z.ZodObject<{
   market: z.ZodCustom<`0x${string}`, `0x${string}`>;
   marketConfigurator: z.ZodCustom<`0x${string}`, `0x${string}`>;
   curatorName: z.ZodNullable<z.ZodString>;
   marketName: z.ZodNullable<z.ZodString>;
+  underlyingSymbol: z.ZodNullable<z.ZodString>;
+  isUnderlying: z.ZodBoolean;
+  quotaLimit: z.ZodNullable<z.ZodNumber>;
+  quotaUsed: z.ZodNullable<z.ZodNumber>;
   token: z.ZodCustom<`0x${string}`, `0x${string}`>;
   tokenSymbol: z.ZodNullable<z.ZodString>;
-  underlyingSymbol: z.ZodNullable<z.ZodString>;
   reserve: z.ZodBoolean;
+  priceOracle: z.ZodCustom<`0x${string}`, `0x${string}`>;
+}, z.core.$loose>;
+/**
+ * {@link PermissionlessMarketSlot} — the same slot read from the chain's end,
+ * so the feed is a column rather than what was asked for.
+ **/
+export declare const marketSlotSchema: z.ZodObject<{
+  market: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  marketConfigurator: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  curatorName: z.ZodNullable<z.ZodString>;
+  marketName: z.ZodNullable<z.ZodString>;
+  underlyingSymbol: z.ZodNullable<z.ZodString>;
   isUnderlying: z.ZodBoolean;
   quotaLimit: z.ZodNullable<z.ZodNumber>;
   quotaUsed: z.ZodNullable<z.ZodNumber>;
-  marketStalenessPeriod: z.ZodNullable<z.ZodNumber>;
+  token: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  tokenSymbol: z.ZodNullable<z.ZodString>;
+  reserve: z.ZodBoolean;
+  priceOracle: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  chainId: z.ZodNumber;
+  underlyingToken: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  isShutdown: z.ZodBoolean;
+  priceFeed: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  priceFeedName: z.ZodNullable<z.ZodString>;
+  priceFeedInStore: z.ZodBoolean;
+  underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
 }, z.core.$loose>;
-/** {@link PermissionlessPriceFeedDetails} */
+/** Every slot in scope, across whichever chains the read covered. */
+export declare const marketSlotsSchema: z.ZodArray<z.ZodObject<{
+  market: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  marketConfigurator: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  curatorName: z.ZodNullable<z.ZodString>;
+  marketName: z.ZodNullable<z.ZodString>;
+  underlyingSymbol: z.ZodNullable<z.ZodString>;
+  isUnderlying: z.ZodBoolean;
+  quotaLimit: z.ZodNullable<z.ZodNumber>;
+  quotaUsed: z.ZodNullable<z.ZodNumber>;
+  token: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  tokenSymbol: z.ZodNullable<z.ZodString>;
+  reserve: z.ZodBoolean;
+  priceOracle: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  chainId: z.ZodNumber;
+  underlyingToken: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  isShutdown: z.ZodBoolean;
+  priceFeed: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  priceFeedName: z.ZodNullable<z.ZodString>;
+  priceFeedInStore: z.ZodBoolean;
+  underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+}, z.core.$loose>>;
+/** {@link PermissionlessIndexedPriceFeedDetails} */
 export declare const priceFeedDetailsSchema: z.ZodObject<{
   chainId: z.ZodNumber;
   priceFeed: z.ZodObject<{
@@ -114,36 +198,34 @@ export declare const priceFeedDetailsSchema: z.ZodObject<{
     marketConfigurator: z.ZodCustom<`0x${string}`, `0x${string}`>;
     curatorName: z.ZodNullable<z.ZodString>;
     marketName: z.ZodNullable<z.ZodString>;
-    token: z.ZodCustom<`0x${string}`, `0x${string}`>;
-    tokenSymbol: z.ZodNullable<z.ZodString>;
     underlyingSymbol: z.ZodNullable<z.ZodString>;
-    reserve: z.ZodBoolean;
     isUnderlying: z.ZodBoolean;
     quotaLimit: z.ZodNullable<z.ZodNumber>;
     quotaUsed: z.ZodNullable<z.ZodNumber>;
-    marketStalenessPeriod: z.ZodNullable<z.ZodNumber>;
+    token: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    tokenSymbol: z.ZodNullable<z.ZodString>;
+    reserve: z.ZodBoolean;
+    priceOracle: z.ZodCustom<`0x${string}`, `0x${string}`>;
   }, z.core.$loose>>;
 }, z.core.$loose>;
-/** {@link PermissionlessPriceFeedMarketCaps} */
-export declare const priceFeedMarketCapsSchema: z.ZodObject<{
-  marketCaps: z.ZodType<Record<`0x${string}`, string | null>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, string | null>, unknown>>;
-  time: z.ZodNumber;
-}, z.core.$loose>;
 /** {@link PermissionlessAssetMarketFeed} */
 export declare const assetMarketFeedSchema: z.ZodObject<{
   address: z.ZodCustom<`0x${string}`, `0x${string}`>;
   name: z.ZodNullable<z.ZodString>;
   inStore: z.ZodBoolean;
 }, z.core.$loose>;
-/** {@link PermissionlessAssetMarket} */
+/** {@link PermissionlessAssetMarket} — the market as what prices the asset in it. */
 export declare const assetMarketSchema: z.ZodObject<{
   market: z.ZodCustom<`0x${string}`, `0x${string}`>;
   marketConfigurator: z.ZodCustom<`0x${string}`, `0x${string}`>;
   curatorName: z.ZodNullable<z.ZodString>;
   marketName: z.ZodNullable<z.ZodString>;
-  underlyingToken: z.ZodCustom<`0x${string}`, `0x${string}`>;
   underlyingSymbol: z.ZodNullable<z.ZodString>;
   isUnderlying: z.ZodBoolean;
+  quotaLimit: z.ZodNullable<z.ZodNumber>;
+  quotaUsed: z.ZodNullable<z.ZodNumber>;
+  underlyingToken: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
   isShutdown: z.ZodBoolean;
   mainFeed: z.ZodNullable<z.ZodObject<{
     address: z.ZodCustom<`0x${string}`, `0x${string}`>;
@@ -155,10 +237,8 @@ export declare const assetMarketSchema: z.ZodObject<{
     name: z.ZodNullable<z.ZodString>;
     inStore: z.ZodBoolean;
   }, z.core.$loose>>;
-  quotaLimit: z.ZodNullable<z.ZodNumber>;
-  quotaUsed: z.ZodNullable<z.ZodNumber>;
 }, z.core.$loose>;
-/** {@link PermissionlessAssetDetails} */
+/** {@link PermissionlessIndexedAssetDetails} */
 export declare const assetDetailsSchema: z.ZodObject<{
   chainId: z.ZodNumber;
   asset: z.ZodObject<{
@@ -180,9 +260,12 @@ export declare const assetDetailsSchema: z.ZodObject<{
     marketConfigurator: z.ZodCustom<`0x${string}`, `0x${string}`>;
     curatorName: z.ZodNullable<z.ZodString>;
     marketName: z.ZodNullable<z.ZodString>;
-    underlyingToken: z.ZodCustom<`0x${string}`, `0x${string}`>;
     underlyingSymbol: z.ZodNullable<z.ZodString>;
     isUnderlying: z.ZodBoolean;
+    quotaLimit: z.ZodNullable<z.ZodNumber>;
+    quotaUsed: z.ZodNullable<z.ZodNumber>;
+    underlyingToken: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
     isShutdown: z.ZodBoolean;
     mainFeed: z.ZodNullable<z.ZodObject<{
       address: z.ZodCustom<`0x${string}`, `0x${string}`>;
@@ -194,16 +277,39 @@ export declare const assetDetailsSchema: z.ZodObject<{
       name: z.ZodNullable<z.ZodString>;
       inStore: z.ZodBoolean;
     }, z.core.$loose>>;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+/** {@link PermissionlessAssetQuota} */
+export declare const assetQuotaSchema: z.ZodObject<{
+  quotaLimit: z.ZodNullable<z.ZodNumber>;
+  quotaUsed: z.ZodNullable<z.ZodNumber>;
+  isShutdown: z.ZodBoolean;
+  underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+}, z.core.$loose>;
+/** {@link PermissionlessIndexedAssetSummary} */
+export declare const assetSummarySchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  symbol: z.ZodString;
+  underlyingMarketCount: z.ZodNumber;
+  marketQuotas: z.ZodArray<z.ZodObject<{
     quotaLimit: z.ZodNullable<z.ZodNumber>;
     quotaUsed: z.ZodNullable<z.ZodNumber>;
+    isShutdown: z.ZodBoolean;
+    underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
   }, z.core.$loose>>;
-  quotaLimitUsd: z.ZodNullable<z.ZodNumber>;
-  quotaUsedUsd: z.ZodNullable<z.ZodNumber>;
-}, z.core.$loose>;
-/** {@link PermissionlessAssetPrices} */
-export declare const assetPricesSchema: z.ZodObject<{
-  prices: z.ZodType<Record<`0x${string}`, string | null>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, string | null>, unknown>>;
-  marketCaps: z.ZodType<Record<`0x${string}`, string | null>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, string | null>, unknown>>;
-  time: z.ZodNumber;
 }, z.core.$loose>;
+/** The list of {@link PermissionlessAssetSummary}, already ordered. */
+export declare const assetSummariesSchema: z.ZodArray<z.ZodObject<{
+  chainId: z.ZodNumber;
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  symbol: z.ZodString;
+  underlyingMarketCount: z.ZodNumber;
+  marketQuotas: z.ZodArray<z.ZodObject<{
+    quotaLimit: z.ZodNullable<z.ZodNumber>;
+    quotaUsed: z.ZodNullable<z.ZodNumber>;
+    isShutdown: z.ZodBoolean;
+    underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+  }, z.core.$loose>>;
+}, z.core.$loose>>;
 //#endregion

package/dist/types/permissionless/api/oracles/score/formula.d.ts

@@ -0,0 +1,36 @@
+import { GroupImpact } from "./types.js";
+//#region src/permissionless/api/oracles/score/formula.d.ts
+/** What every source of a group is made to answer, as a multiple of now. */
+export declare 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.
+ */
+export declare function scoreOfFactor(factor: number | null): number | null;
+/**
+ * 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.
+ */
+export declare function finalPrice(main: bigint | null, reserve: bigint | null | undefined): bigint | null;
+/** `stressed / base` as a float, `null` where the stressed price is gone. */
+export declare function factorOf(base: bigint, stressed: bigint | null): number | null;
+/**
+ * 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.
+ */
+export declare function worstOf(impacts: GroupImpact[]): {
+  score: number;
+  impacts: GroupImpact[];
+  worst: GroupImpact | null;
+};
+//#endregion

package/dist/types/permissionless/api/oracles/score/index.d.ts

@@ -0,0 +1,4 @@
+import { AssetScore, AssetScoresArgs, FeedPairScore, FeedPairScoreArgs, GroupImpact, MarketScore, ScoredFeed } from "./types.js";
+import { SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./formula.js";
+import { runAssetScores, runFeedPairScore } from "./run.js";
+export { AssetScore, AssetScoresArgs, FeedPairScore, FeedPairScoreArgs, GroupImpact, MarketScore, SCORE_MULTIPLIER, ScoredFeed, factorOf, finalPrice, runAssetScores, runFeedPairScore, scoreOfFactor, worstOf };

package/dist/types/permissionless/api/oracles/score/run.d.ts

@@ -0,0 +1,42 @@
+import { AssetScore, FeedPairScore } from "./types.js";
+import { PermissionlessMarketSlot } from "../types.js";
+import { Address, Chain, PublicClient, Transport } from "viem";
+//#region src/permissionless/api/oracles/score/run.d.ts
+type Logger = {
+  warn(message: string): void;
+};
+/**
+ * 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}.
+ **/
+export declare function runAssetScores({ client, chainId, slots, compressor, logger }: {
+  client: PublicClient<Transport, Chain>;
+  chainId: number;
+  slots: PermissionlessMarketSlot[];
+  compressor: Address;
+  logger?: Logger;
+}): Promise<AssetScore[]>;
+/**
+ * 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.
+ **/
+export declare function runFeedPairScore({ client, chainId, compressor, main, reserve, logger }: {
+  client: PublicClient<Transport, Chain>;
+  chainId: number;
+  compressor: Address;
+  main: Address;
+  reserve?: Address;
+  logger?: Logger;
+}): Promise<FeedPairScore>;
+//#endregion
+export {};

package/dist/types/permissionless/api/oracles/score/types.d.ts

@@ -0,0 +1,118 @@
+import { Address } from "viem";
+//#region src/permissionless/api/oracles/score/types.d.ts
+/**
+ * One of a market's two feeds for a token, as the score reads it.
+ **/
+export interface ScoredFeed {
+  feed: Address;
+  /**
+   * The store's name for the feed, `null` where it has none or where the
+   * feed was named by address alone, as a pair to score is.
+   */
+  name: string | null;
+  /** Gearbox contract type of the feed itself, `""` for one it never deployed. */
+  contractType: string;
+  /**
+   * Every source group beneath the feed: `"Chainlink"`, `"Lido"`, or the
+   * description of a source nothing could name.
+   */
+  sources: string[];
+}
+/**
+ * What one source group, lying, does to the price a market holds for an
+ * asset.
+ **/
+export interface GroupImpact {
+  group: string;
+  /** The group was recognised rather than inferred from one feed's name. */
+  identified: boolean;
+  /**
+   * The group's sources this market's feeds read, by what they say they are:
+   * `"stETH / ETH"`, `"ETH / USD"`.
+   */
+  feeds: string[];
+  /** Which of the market's feeds read the group. */
+  reaches: "main" | "reserve" | "both";
+  /**
+   * The final price under the lie over the final price now, in USD. `null` is
+   * a price that stopped answering.
+   */
+  factor: number | null;
+  /** 1 to 10, by {@link scoreOfFactor}; `null` where the price stopped answering. */
+  score: number | null;
+}
+/**
+ * How far the price a main and a reserve feed give together can be pushed:
+ * their manipulation resistance, from 1 (does not move) to 10 (takes the
+ * whole lie).
+ *
+ * Every source group behind the two feeds is made, one group at a time, to
+ * answer {@link SCORE_MULTIPLIER} times what it answers now. The pair scores
+ * by the group that moves its final price — `min(main, reserve)` — the
+ * furthest, as a multiple either way.
+ **/
+export interface FeedPairScore {
+  main: ScoredFeed;
+  /** `null` where there is no reserve at all. */
+  reserve: ScoredFeed | null;
+  /**
+   * The final price is `min(main, reserve)`: a reserve is present, is not a
+   * `ZeroPriceFeed`, and answers. Where it is not, the final price is the
+   * main feed's alone.
+   */
+  hasReserve: boolean;
+  /** The final price now, in USD. */
+  price: number;
+  /** Every group behind the two feeds, the most damaging first. */
+  impacts: GroupImpact[];
+  /** The group the score comes from; `null` where no group moves the price. */
+  worst: GroupImpact | null;
+  /**
+   * The score rests on a source nothing could name.
+   *
+   * Such a source is a group of its own and is perturbed alone, so where one
+   * feed reads it and the other does not, the other is taken to hold — which
+   * it would not if one operator stood behind both.
+   */
+  unverified: boolean;
+  score: number;
+  /** How the pair is set up, where that explains its score. */
+  notes: string[];
+}
+/** One market's price for one asset, scored as the pair of feeds it holds. */
+export interface MarketScore extends FeedPairScore {
+  market: Address;
+  marketName: string | null;
+  marketConfigurator: Address;
+  curatorName: string | null;
+}
+/**
+ * One asset's score: its worst market's.
+ *
+ * The maximum, not an average, because the asset is only as well guarded as
+ * the most exposed market that prices it.
+ **/
+export interface AssetScore {
+  chainId: number;
+  asset: Address;
+  symbol: string | null;
+  /** `null` for an asset no running market prices: it is switched off in all. */
+  score: number | null;
+  /** Some market's score rests on a source nothing could name. */
+  unverified: boolean;
+  /** The market the score comes from. */
+  worst: MarketScore | null;
+  /** Every running market pricing the asset, worst first. */
+  markets: MarketScore[];
+}
+export interface AssetScoresArgs {
+  /** Omitted scores every chain the backend serves markets for. */
+  chainId?: number;
+}
+export interface FeedPairScoreArgs {
+  chainId: number;
+  main: Address;
+  /** Omitted scores the main feed alone, as a market with no reserve. */
+  reserve?: Address;
+}
+//#endregion

package/dist/types/permissionless/api/oracles/stress/classify.d.ts

@@ -0,0 +1,57 @@
+import { StressSource } from "./types.js";
+import { Address } from "viem";
+//#region src/permissionless/api/oracles/stress/classify.d.ts
+/**
+ * Who a price ultimately comes from, worked out from what the chain says
+ * about the feed reporting it.
+ *
+ * There is no registry on chain of which aggregator belongs to whom, so this
+ * is a reading of three things the chain does carry: the Gearbox contract
+ * type, which names the provider outright for the feeds Gearbox deploys; the
+ * `description()` every Chainlink-shaped feed returns; and the interface
+ * version, which separates Chainlink's own proxies from the many contracts
+ * that imitate them.
+ *
+ * Every rule is open to inspection and every unmatched feed is reported as
+ * unmatched, because the alternative — guessing from a symbol, or sweeping
+ * the remainder into one bucket — would understate exactly the part of the
+ * answer a reader should distrust.
+ **/
+/** One node of an oracle's feed tree, as the compressor reports it. */
+export interface TreeNode {
+  address: Address;
+  /** Gearbox contract type, `""` for a contract it never deployed. */
+  contractType: string;
+  /** `AggregatorV3Interface.version()`, or 0 where there is none. */
+  version: number;
+  description: string;
+  /** The feeds it reads, lowercased. Empty makes it a leaf. */
+  underlyingFeeds: Address[];
+}
+/**
+ * Every source behind a chain's feed trees.
+ *
+ * A source per contract, not per feed: two of an oracle's trees carrying the
+ * same aggregator is one source read twice, and the test varies it once.
+ *
+ * `rateTargets` says which contract each rate-bearing feed reads its rate
+ * from — the feed's own `lpContract`, read separately because the compressor
+ * does not report it. A feed missing from it is left out with a reason, since
+ * perturbing the whole feed instead would charge its protocol with a failure
+ * of whatever prices the thing the rate is denominated in.
+ **/
+export declare function classifySources(chainId: number, nodes: TreeNode[], rateTargets: Map<Address, Address>, baselineOf: (target: Address) => bigint | null): {
+  sources: StressSource[];
+  unresolved: TreeNode[];
+};
+/**
+ * The sources each of the given feeds is priced through, following the trees
+ * down from every one of them.
+ *
+ * A feed is reached by a source when the source sits anywhere beneath it, at
+ * any depth: a market reading a composite of a composite of a Chainlink
+ * aggregator is a market Chainlink can move. Memoised over the whole forest,
+ * so a node shared by twenty trees is walked once.
+ **/
+export declare function sourcesByFeed(roots: Address[], nodes: Map<Address, TreeNode>, sources: StressSource[]): Map<Address, Set<Address>>;
+//#endregion

package/dist/types/permissionless/api/oracles/stress/index.d.ts

@@ -0,0 +1,6 @@
+import { BreakingPoint, FeedOutcome, GroupReport, GroupScenarioOutcome, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs } from "./types.js";
+import { TreeNode, classifySources, sourcesByFeed } from "./classify.js";
+import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./override.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readFeedTrees, readForest, readRateTargets, readUnder, runStressTest } from "./run.js";
+import { scoreGroup, slotHarm, verdictOf } from "./score.js";
+export { BreakingPoint, DEFAULT_SCENARIOS, FeedOutcome, GroupReport, GroupScenarioOutcome, RATE_FEED_TYPE, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, groupOverride, perturb, rateStub, readFeedTrees, readForest, readRateTargets, readUnder, roundDataStub, runStressTest, scoreGroup, slotHarm, sourcesByFeed, verdictOf };

package/dist/types/permissionless/api/oracles/stress/override.d.ts

@@ -0,0 +1,59 @@
+import { StressSource } from "./types.js";
+import { Hex, StateOverride } from "viem";
+//#region src/permissionless/api/oracles/stress/override.d.ts
+/**
+ * Runtime code answering every call with the same five words.
+ *
+ * Deliberately selector-blind. A price feed is read through more than
+ * `latestRoundData` — `decimals`, `version`, sometimes `latestAnswer` — and
+ * dispatching on each would mean knowing which of them every caller in a tree
+ * reaches for. Five words decode as the round data; a caller expecting one
+ * word reads the first, which is why `roundId` is set to the 8 decimals every
+ * Gearbox feed reports rather than to a round number.
+ *
+ * `answeredInRound` is the same 8, so the `answeredInRound >= roundId` check
+ * the older consumers make passes.
+ **/
+export declare function roundDataStub(answer: bigint, updatedAt: bigint): Hex;
+/**
+ * Runtime code answering every call with one word.
+ *
+ * What an exchange rate getter returns, whichever of them the feed calls:
+ * `stEthPerToken`, `convertToAssets`, `get_virtual_price`, `pricePerShare`
+ * and `getRate` all answer a single `uint256`, so the stub does not need to
+ * know which.
+ **/
+export declare function rateStub(rate: bigint): Hex;
+/**
+ * The two unbounded ends, as far as the types involved can carry them.
+ *
+ * "Infinitely large" has to stop somewhere: a price is an `int256` and the
+ * arithmetic above it multiplies, so a genuinely enormous answer overflows
+ * inside the composite feed and reverts — which would be scored as the
+ * oracle resisting, when all that happened is that the test asked something
+ * the type cannot hold. `1e12` times the current answer is past any bound,
+ * any sanity check and any collateral ratio, and still multiplies.
+ */
+export declare const UNBOUNDED_UP = 1000000000000;
+/** The other end: a thousandth of a trillionth, which is as near zero. */
+export declare const UNBOUNDED_DOWN = 1e-12;
+/**
+ * What a source should answer under a multiplier, given what it answers now.
+ *
+ * Floored at one rather than at zero: a multiplier small enough to round the
+ * baseline away would be testing a feed reporting nothing, which is the revert
+ * case and is a different scenario with a different meaning.
+ */
+export declare function perturb(baseline: bigint, multiplier: number): bigint;
+/**
+ * The state override that makes every source of a group answer a multiple of
+ * what it answers now.
+ *
+ * One override per contract, so a group whose sources share an aggregator
+ * perturbs it once. Sources with nothing behind them and sources that are not
+ * answering are both left out, for the reasons on
+ * {@link StressSource.perturbable} and {@link StressSource.baseline} — an
+ * empty result is a group there is nothing to simulate about.
+ **/
+export declare function groupOverride(sources: StressSource[], multiplier: number, updatedAt: bigint): StateOverride;
+//#endregion