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

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

@@ -5,7 +5,9 @@ import { AttachChainsArgs, ChainScope, ChainSummaryArgs, PermissionlessChain, Pe
 import { ChainsNamespace } from "./chains/ChainsNamespace.js";
 import { DeployArgs, DeployContractArgs, DeployPriceFeedArgs, PreparedDeployment, PreparedPriceFeedDeployment } from "./deploy/types.js";
 import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./deploy/PermissionlessDeploy.js";
-import { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedPrice, PriceFeedRef } from "./oracles/types.js";
+import { AssetScore, AssetScoresArgs, GroupImpact, MarketScore, ScoredFeed } from "./oracles/score/types.js";
+import { BreakingPoint, FeedOutcome, GroupReport, GroupScenarioOutcome, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs } from "./oracles/stress/types.js";
+import { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessMarketSlot, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedDecimals, PriceFeedPrice, PriceFeedRef } from "./oracles/types.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
 import { AddFeedsArgs, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ForbidFeedsArgs, InstanceTxsArgs, PriceFeedPair } from "./transactions/types.js";
 import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransactions.js";
@@ -15,6 +17,12 @@ import "./chains/index.js";
 import { deriveEffectiveStalenessPeriod } from "./deploy/effective-staleness.js";
 import "./deploy/index.js";
 import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./errors.js";
+import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./oracles/score/formula.js";
+import { runAssetScores } from "./oracles/score/run.js";
+import { TreeNode, classifySources, sourcesByFeed } from "./oracles/stress/classify.js";
+import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./oracles/stress/override.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest } from "./oracles/stress/run.js";
+import { scoreGroup, slotHarm, verdictOf } from "./oracles/stress/score.js";
 import "./oracles/index.js";
 import "./transactions/index.js";
-export { AddFeedsArgs, AssetArgs, AssetCap, AssetsArgs, AttachChainsArgs, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, FeedCap, ForbidFeedsArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, InstanceOwnerTransactions, InstanceTxsArgs, MarketCap, PermissionlessAnalytics, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PreparedDeployment, PreparedPriceFeedDeployment, PriceChartArgs, PriceFeedArgs, PriceFeedChartPoint, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedPrice, PriceFeedPriceChart, PriceFeedRef, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };
+export { AddFeedsArgs, AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, AttachChainsArgs, BreakingPoint, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, FeedCap, FeedOutcome, ForbidFeedsArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GroupImpact, GroupReport, GroupScenarioOutcome, InstanceOwnerTransactions, InstanceTxsArgs, MarketCap, MarketScore, PermissionlessAnalytics, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessMarketSlot, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PreparedDeployment, PreparedPriceFeedDeployment, PriceChartArgs, PriceFeedArgs, PriceFeedChartPoint, PriceFeedDecimals, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedPrice, PriceFeedPriceChart, PriceFeedRef, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, RATE_FEED_TYPE, REVERT_SCORE, SCORE_MULTIPLIER, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, 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/types/permissionless/api/oracles/PermissionlessOracles.d.ts

@@ -2,7 +2,9 @@ import { PriceFeedData } from "../../../model/opportunities.js";
 import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
 import { GearboxPermissionlessOptions } from "../types.js";
 import { ChainsNamespace } from "../chains/ChainsNamespace.js";
-import { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAssetDetails, PermissionlessAssetSummary, PermissionlessPriceFeedDetails, PermissionlessPriceFeedStore, PriceFeedArgs, PriceFeedPrice, PriceFeedRef } from "./types.js";
+import { AssetScore, AssetScoresArgs } from "./score/types.js";
+import { StressReport, StressTestArgs } from "./stress/types.js";
+import { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAssetDetails, PermissionlessAssetSummary, PermissionlessMarketSlot, PermissionlessPriceFeedDetails, PermissionlessPriceFeedStore, PriceFeedArgs, PriceFeedDecimals, PriceFeedPrice, PriceFeedRef } from "./types.js";
 //#region src/permissionless/api/oracles/PermissionlessOracles.d.ts
 export declare const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID: Record<number, bigint>;
 export declare const GET_PRICES_CHUNK_SIZE = 200;
@@ -59,6 +61,25 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * ```
    **/
   stores({ chainId }?: AssetsArgs): Promise<PermissionlessPriceFeedStore[]>;
+  /**
+   * 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 });
+   * ```
+   **/
+  slots({ chainId }?: AssetsArgs): Promise<PermissionlessMarketSlot[]>;
   /**
    * One feed of the store: what it is, which assets it may price, and which
    * market slots it currently fills.
@@ -127,6 +148,74 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * ```
    **/
   assets({ chainId }?: AssetsArgs): Promise<PermissionlessAssetSummary[]>;
+  /**
+   * 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.
+   **/
+  assetScores({ chainId }?: AssetScoresArgs): Promise<AssetScore[]>;
+  stressTest({ chainId, ...options }: StressTestArgs): Promise<StressReport>;
   /**
    * The feeds one feed reads from, recursively.
    *
@@ -172,6 +261,31 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * the 8 decimals every Gearbox feed reports.
    **/
   getPrices(feeds: PriceFeedRef[]): Promise<PriceFeedPrice[]>;
+  /**
+   * 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.
+   **/
+  getDecimals(feeds: PriceFeedRef[]): Promise<PriceFeedDecimals[]>;
   /**
    * What one chain's feeds value one chain's assets at: `price × totalSupply`
    * per pair.

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

@@ -1,3 +1,13 @@
-import { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedPrice, PriceFeedRef } from "./types.js";
+import { AssetScore, AssetScoresArgs, GroupImpact, MarketScore, ScoredFeed } from "./score/types.js";
+import { BreakingPoint, FeedOutcome, GroupReport, GroupScenarioOutcome, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs } from "./stress/types.js";
+import { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessMarketSlot, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedDecimals, PriceFeedPrice, PriceFeedRef } from "./types.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./PermissionlessOracles.js";
-export { AssetArgs, AssetCap, AssetsArgs, FeedCap, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedPrice, PriceFeedRef };
+import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./score/formula.js";
+import { runAssetScores } from "./score/run.js";
+import "./score/index.js";
+import { TreeNode, classifySources, sourcesByFeed } from "./stress/classify.js";
+import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./stress/override.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, readUnder, runStressTest } from "./stress/run.js";
+import { scoreGroup, slotHarm, verdictOf } from "./stress/score.js";
+import "./stress/index.js";
+export { AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, BreakingPoint, DEFAULT_SCENARIOS, FeedCap, FeedOutcome, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GroupImpact, GroupReport, GroupScenarioOutcome, MarketCap, MarketScore, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessMarketSlot, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedDecimals, PriceFeedPrice, PriceFeedRef, RATE_FEED_TYPE, REVERT_SCORE, SCORE_MULTIPLIER, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, factorOf, finalPrice, groupOverride, perturb, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };

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

@@ -129,6 +129,53 @@ export declare const priceFeedMarketSchema: z.ZodObject<{
   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>;
+  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>;
+/** 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;

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

@@ -0,0 +1,39 @@
+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 = 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.
+ */
+export declare 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.
+ */
+export declare function scoreOfFactor(factor: number | null): number;
+/**
+ * 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 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.
+ */
+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, GroupImpact, MarketScore, ScoredFeed } from "./types.js";
+import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./formula.js";
+import { runAssetScores } from "./run.js";
+export { AssetScore, AssetScoresArgs, GroupImpact, MarketScore, REVERT_SCORE, SCORE_MULTIPLIER, ScoredFeed, factorOf, finalPrice, runAssetScores, scoreOfFactor, worstOf };

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

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

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

@@ -0,0 +1,113 @@
+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. */
+  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;
+  /**
+   * The same, against the market's own underlying: what an account is
+   * valued by. A lie that moves collateral and underlying alike leaves it at
+   * 1. `null` where either price stopped answering.
+   */
+  ratioFactor: number | null;
+  /** 0 to 10, by {@link scoreOfFactor}. */
+  score: number;
+}
+/**
+ * How well one market guards one asset's price, out of 10.
+ *
+ * Every source group behind the asset's feeds is made, one group at a time,
+ * to answer {@link SCORE_MULTIPLIER} times what it answers now. The market
+ * scores by the group that moves its final price — `min(main, reserve)` —
+ * the furthest.
+ **/
+export interface MarketScore {
+  market: Address;
+  marketName: string | null;
+  marketConfigurator: Address;
+  curatorName: string | null;
+  main: ScoredFeed;
+  /** `null` where the market holds no reserve for the asset 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 source feeds 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 market is set up, where that explains its score. */
+  notes: string[];
+}
+/**
+ * One asset's score: its worst market's.
+ *
+ * The minimum, not an average, because the asset is only as well guarded as
+ * the most exposed market that accepts it.
+ **/
+export interface AssetScore {
+  chainId: number;
+  asset: Address;
+  symbol: string | null;
+  /**
+   * `null` for an asset no running market accepts as collateral: every
+   * market has it switched off, or it is only ever a market's underlying.
+   */
+  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;
+}
+//#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, 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, 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

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

@@ -0,0 +1,89 @@
+import { StressReport, StressScenario, StressSource } from "./types.js";
+import { PermissionlessMarketSlot } from "../types.js";
+import { TreeNode } from "./classify.js";
+import { Address, Chain, PublicClient, Transport } from "viem";
+//#region src/permissionless/api/oracles/stress/run.d.ts
+/**
+ * The two ends the question is asked at, which is what "infinitely large and
+ * infinitely small" comes to once a type has to hold it.
+ */
+export declare const DEFAULT_SCENARIOS: StressScenario[];
+/**
+ * The Gearbox LP feeds: a protocol's exchange rate, clamped to a window the
+ * feed holds, times the price of what the rate is denominated in.
+ */
+export declare const RATE_FEED_TYPE: RegExp;
+/**
+ * The feed trees of every oracle the chain's markets use, flattened.
+ *
+ * One call per oracle and not per feed: the compressor answers an oracle's
+ * entire tree at once, with every node's type, description, children and
+ * current answer, which is the whole of what this test needs off the chain.
+ * A node carried by several oracles is one node — the trees overlap heavily,
+ * since the aggregators under them are the same handful.
+ */
+export declare function readForest(client: PublicClient<Transport, Chain>, compressor: Address, oracles: Address[]): Promise<{
+  nodes: Map<Address, TreeNode>;
+  answers: Map<Address, bigint | null>;
+  unreadableOracles: Address[];
+}>;
+/**
+ * Where each rate-bearing feed reads its rate, and what it will accept.
+ *
+ * The baseline a rate source is perturbed from is the feed's own `lowerBound`
+ * and not the rate itself. Reading the rate would mean knowing which getter
+ * each protocol publishes it under — `stEthPerToken`, `convertToAssets`,
+ * `get_virtual_price`, `pricePerShare` — and in exactly which units, which is
+ * a table that goes stale. The bound is within the feed's own accepted window
+ * of the live rate by construction, so it is the same figure to within that
+ * window, which is two percent or so. That is immaterial against the
+ * multipliers the ends of the sweep use, and at the fine end of the threshold
+ * search the bound *is* the answer: an LP feed clamps the rate it accepts, so
+ * where it breaks is where its bound is.
+ */
+export declare function readRateTargets(client: PublicClient<Transport, Chain>, feeds: Address[]): Promise<{
+  targets: Map<Address, Address>;
+  baselines: Map<Address, bigint>;
+  bounds: Map<Address, {
+    lower: bigint;
+    upper: bigint;
+  }>;
+}>;
+/**
+ * What every feed answers with one group's sources overridden.
+ *
+ * One `eth_call` for the whole chain: the overrides go in once and the feeds
+ * are read through a multicall inside them, so a group costs a round trip per
+ * scenario rather than a round trip per feed. A feed that reverts comes back
+ * `null`, which is an outcome and not an error.
+ */
+export declare function readUnder(client: PublicClient<Transport, Chain>, feeds: Address[], sources: StressSource[], multiplier: number, updatedAt: bigint,
+/**
+ * Sources re-answered as they stand, under a fresh timestamp: a pull feed
+ * nobody has pushed to lately is stale, and a feed over it reverts on that
+ * before anything about the price is learnt. `sources` win where the two
+ * overlap.
+ */
+freshen?: StressSource[]): Promise<Map<Address, bigint | null>>;
+/**
+ * Every source behind one chain's markets, put through the sweep a group at a
+ * time.
+ *
+ * Takes the slots as read, so the caller decides whether that read came from
+ * the backend or from somewhere else, and takes a client rather than making
+ * one, so the whole thing is testable against a stub.
+ **/
+export declare function runStressTest({ client, chainId, slots, compressor, scenarios, thresholds, groups: only, logger }: {
+  client: PublicClient<Transport, Chain>;
+  chainId: number;
+  slots: PermissionlessMarketSlot[];
+  compressor: Address;
+  scenarios?: StressScenario[];
+  thresholds?: boolean;
+  groups?: string[];
+  logger?: {
+    warn(message: string): void;
+    debug?(message: string): void;
+  };
+}): Promise<StressReport>;
+//#endregion