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

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

@@ -5,7 +5,7 @@ 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 { AssetScore, AssetScoresArgs, GroupImpact, MarketScore, ScoredFeed } from "./oracles/score/types.js";
+import { AssetScore, AssetScoresArgs, FeedPairScore, FeedPairScoreArgs, 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";
@@ -17,12 +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 { SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./oracles/score/formula.js";
+import { runAssetScores, runFeedPairScore } 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 { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readFeedTrees, 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, 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 };
+export { AddFeedsArgs, AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, AttachChainsArgs, BreakingPoint, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, FeedCap, FeedOutcome, FeedPairScore, FeedPairScoreArgs, 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, SCORE_MULTIPLIER, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, deriveEffectiveStalenessPeriod, factorOf, finalPrice, groupOverride, perturb, priceFeedSalt, rateStub, readFeedTrees, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runFeedPairScore, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };

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

@@ -2,7 +2,7 @@ import { PriceFeedData } from "../../../model/opportunities.js";
 import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
 import { GearboxPermissionlessOptions } from "../types.js";
 import { ChainsNamespace } from "../chains/ChainsNamespace.js";
-import { AssetScore, AssetScoresArgs } from "./score/types.js";
+import { AssetScore, AssetScoresArgs, FeedPairScore, FeedPairScoreArgs } 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
@@ -192,14 +192,16 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * three leaves anything to simulate.
    **/
   /**
-   * Every asset's score out of 10 for how its markets guard its price.
+   * Every asset's manipulation resistance: how far, from 1 to 10 times, a
+   * lying source can push the price its markets hold for it.
    *
    * 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
+   * so on — is made in turn to answer ten 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.
+   * reserve)`, as a multiple either way: 1 for not at all, 1.04 for 4%, 10
+   * for the whole lie. A group under which the price stops answering moves
+   * nothing and is listed rather than scored. An asset scores its worst
+   * running market, underlying or 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
@@ -215,6 +217,28 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * {@link GearboxPermissionless.attach} has resolved.
    **/
   assetScores({ chainId }?: AssetScoresArgs): Promise<AssetScore[]>;
+  /**
+   * The manipulation resistance of any main feed and reserve on a chain,
+   * scored the way {@link assetScores} scores a market holding them — for
+   * trying a pair before any market does.
+   *
+   * ```ts
+   * const pair = await permissionless.oracles.feedPairScore({
+   *   chainId: 1,
+   *   main: "0x…",
+   *   reserve: "0x…",
+   * });
+   * ```
+   *
+   * Reads the chain directly, through state overrides in `eth_call`, so the
+   * client has to have attached and the node behind it has to accept them.
+   *
+   * @throws When the client has not attached, when the chain has no client or
+   * no PriceFeedCompressor, or when there is nothing to score: a feed the
+   * compressor cannot read, a `ZeroPriceFeed` main, or a final price that does
+   * not answer.
+   **/
+  feedPairScore({ chainId, main, reserve }: FeedPairScoreArgs): Promise<FeedPairScore>;
   stressTest({ chainId, ...options }: StressTestArgs): Promise<StressReport>;
   /**
    * The feeds one feed reads from, recursively.

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

@@ -1,13 +1,13 @@
-import { AssetScore, AssetScoresArgs, GroupImpact, MarketScore, ScoredFeed } from "./score/types.js";
+import { AssetScore, AssetScoresArgs, FeedPairScore, FeedPairScoreArgs, 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";
-import { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./score/formula.js";
-import { runAssetScores } from "./score/run.js";
+import { SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./score/formula.js";
+import { runAssetScores, runFeedPairScore } 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 { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readFeedTrees, 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 };
+export { AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, BreakingPoint, DEFAULT_SCENARIOS, FeedCap, FeedOutcome, FeedPairScore, FeedPairScoreArgs, 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, SCORE_MULTIPLIER, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, factorOf, finalPrice, groupOverride, perturb, rateStub, readFeedTrees, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runFeedPairScore, runStressTest, scoreGroup, scoreOfFactor, slotHarm, sourcesByFeed, verdictOf, worstOf };

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

@@ -1,23 +1,17 @@
 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;
+export declare const SCORE_MULTIPLIER = 10;
 /**
- * The score of a price that stops answering under the lie.
+ * 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.
  *
- * Half marks: nobody can borrow against a wrong number, but nobody can be
- * liquidated either until the feed is replaced.
+ * `null` for a price that stopped answering, which is not a move.
  */
-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;
+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
@@ -27,9 +21,12 @@ export declare function finalPrice(main: bigint | null, reserve: 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.
+ * 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;

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

@@ -1,4 +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 };
+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

@@ -1,24 +1,42 @@
-import { AssetScore } from "./types.js";
+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, 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.
+ * 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?: {
-    warn(message: string): void;
-  };
+  logger?: Logger;
 }): Promise<AssetScore[]>;
-//#endregion
+/**
+ * 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

@@ -5,7 +5,10 @@ import { Address } from "viem";
  **/
 export interface ScoredFeed {
   feed: Address;
-  /** The store's name for the feed, `null` where it has none. */
+  /**
+   * 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;
@@ -35,30 +38,22 @@ export interface GroupImpact {
    * 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;
+  /** 1 to 10, by {@link scoreOfFactor}; `null` where the price stopped answering. */
+  score: number | null;
 }
 /**
- * How well one market guards one asset's price, out of 10.
+ * 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 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.
+ * 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 MarketScore {
-  market: Address;
-  marketName: string | null;
-  marketConfigurator: Address;
-  curatorName: string | null;
+export interface FeedPairScore {
   main: ScoredFeed;
-  /** `null` where the market holds no reserve for the asset at all. */
+  /** `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
@@ -70,7 +65,7 @@ export interface MarketScore {
   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. */
+  /** 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.
@@ -81,23 +76,27 @@ export interface MarketScore {
    */
   unverified: boolean;
   score: number;
-  /** How the market is set up, where that explains its score. */
+  /** 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 minimum, not an average, because the asset is only as well guarded as
- * the most exposed market that accepts it.
+ * 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 accepts as collateral: every
-   * market has it switched off, or it is only ever a market's underlying.
-   */
+  /** `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;
@@ -110,4 +109,10 @@ 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/index.d.ts

@@ -1,6 +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 { 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, readForest, readRateTargets, readUnder, roundDataStub, runStressTest, scoreGroup, slotHarm, sourcesByFeed, verdictOf };
+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/run.d.ts

@@ -27,6 +27,17 @@ export declare function readForest(client: PublicClient<Transport, Chain>, compr
   answers: Map<Address, bigint | null>;
   unreadableOracles: Address[];
 }>;
+/**
+ * The trees under a handful of feeds, flattened, whether or not any oracle
+ * holds them.
+ *
+ * One call for all of them: the compressor walks the feeds it is given the
+ * way it walks an oracle's, and answers with the same nodes.
+ */
+export declare function readFeedTrees(client: PublicClient<Transport, Chain>, compressor: Address, feeds: Address[]): Promise<{
+  nodes: Map<Address, TreeNode>;
+  answers: Map<Address, bigint | null>;
+}>;
 /**
  * Where each rate-bearing feed reads its rate, and what it will accept.
  *

package/dist/types/permissionless/bindings/bytecode-repository.d.ts

@@ -1145,11 +1145,15 @@ declare const abi: readonly [{
   }];
   readonly name: "VersionNotFoundException";
 }];
-interface ComputeAddressArgs {
+export interface ComputeAddressArgs {
   contractType: string;
   version: number;
   encodedParams: Hex;
   salt: Hex;
+  /**
+   * Deployer, i.e. address that will call `deploy` on the bytecode repository.
+   * It is mixed into the salt, so it is not necessarily the owner of the deployed contract
+   */
   owner: Address;
 }
 export declare class BytecodeRepositoryContract extends BaseContract<typeof abi> {
@@ -1171,6 +1175,11 @@ export declare class BytecodeRepositoryContract extends BaseContract<typeof abi>
   isBytecodeUploaded(hash: `0x${string}`): Promise<boolean>;
   isBytecodeAudited(hash: `0x${string}`): Promise<boolean>;
   getLatestVersion(type_: string): Promise<bigint>;
+  /**
+   * Returns the latest allowed patch version of the contract type within given minor version
+   * @throws if no bytecode of this contract type and minor version is allowed
+   */
+  getLatestPatchVersion(type_: string, minorVersion: number): Promise<number>;
   getAllowedBytecodeHash(type_: string, version: number): Promise<Hex>;
   isPublicDomain(domain: string): Promise<boolean>;
   isSystemDomain(domain: string): Promise<boolean>;

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

@@ -1,5 +1,5 @@
 import { AddressProviderContract } from "./address-provider.js";
-import { BytecodeRepositoryContract } from "./bytecode-repository.js";
+import { BytecodeRepositoryContract, ComputeAddressArgs } from "./bytecode-repository.js";
 import { TokenCompressorContract } from "./compressors/token-compressor.js";
 import { WithdrawalCompressorContract } from "./compressors/withdrawal-compressor.js";
 import "./compressors/index.js";
@@ -9,7 +9,8 @@ import { GovernorContract } from "./governance/governor.js";
 import { TimeLockContract } from "./governance/timelock.js";
 import "./governance/index.js";
 import { InstanceManagerContract } from "./instance-manager.js";
-import { AccessMode, AddAssetParams, AllowTokenParams, CreditManagerFees, DeployParams, ForbidAdapterParams, ForbidTokenParams, Market, PauseCreditManagerParams, PeripheryDomain, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, UnpauseCreditManagerParams } from "./types.js";
+import { KILL_SWITCH_PROXY_MINOR_VERSION, KillSwitchProxyContract, KillSwitchProxyNotAllowedError, PreparedKillSwitchProxyDeployment, killSwitchProxySalt } from "./kill-switch-proxy.js";
+import { AccessMode, AddAssetParams, AllowTokenParams, CreditManagerFees, DeployParams, EmergencyAdmin, ForbidAdapterParams, ForbidTokenParams, Market, PauseCreditManagerParams, PeripheryDomain, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, UnpauseCreditManagerParams } from "./types.js";
 import { MarketConfiguratorContract } from "./market-configurator.js";
 import { MarketConfiguratorFactoryContract } from "./market-configurator-factory.js";
 import { PriceFeedStoreContract } from "./price-feed-store.js";
@@ -17,4 +18,4 @@ import { priceFeedSetupParams } from "./pricefeeds/index.js";
 import { RoutingManagerContract } from "./router/routing-manager.js";
 import "./router/index.js";
 import { TreasurySplitterContract } from "./treasury-splitter.js";
-export { AccessMode, AddAssetParams, AddressProviderContract, AllowTokenParams, BytecodeRepositoryContract, ConstructorParams, CreditManagerFees, CrossChainMultisigContract, DeployParams, ForbidAdapterParams, ForbidTokenParams, GovernorContract, InstanceManagerContract, Market, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PauseCreditManagerParams, PeripheryDomain, PriceFeedStoreContract, Proposal, QueuedAndExecutedTransaction, RoutingManagerContract, SafeBatch, SafeMeta, SafeTx, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, TimeLockContract, TimelockTransaction, TimelockTxParams, TokenCompressorContract, TreasurySplitterContract, UnpauseCreditManagerParams, WithdrawalCompressorContract, priceFeedSetupParams };
+export { AccessMode, AddAssetParams, AddressProviderContract, AllowTokenParams, BytecodeRepositoryContract, ComputeAddressArgs, ConstructorParams, CreditManagerFees, CrossChainMultisigContract, DeployParams, EmergencyAdmin, ForbidAdapterParams, ForbidTokenParams, GovernorContract, InstanceManagerContract, KILL_SWITCH_PROXY_MINOR_VERSION, KillSwitchProxyContract, KillSwitchProxyNotAllowedError, Market, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PauseCreditManagerParams, PeripheryDomain, PreparedKillSwitchProxyDeployment, PriceFeedStoreContract, Proposal, QueuedAndExecutedTransaction, RoutingManagerContract, SafeBatch, SafeMeta, SafeTx, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, TimeLockContract, TimelockTransaction, TimelockTxParams, TokenCompressorContract, TreasurySplitterContract, UnpauseCreditManagerParams, WithdrawalCompressorContract, killSwitchProxySalt, priceFeedSetupParams };

package/dist/types/permissionless/bindings/kill-switch-proxy.d.ts

@@ -0,0 +1,205 @@
+import { ParsedCallArgs } from "../../onchain/base/types.js";
+import { RawTx } from "../../onchain/types/transactions.js";
+import { BaseContract } from "../../onchain/base/BaseContract.js";
+import "../../onchain/index.js";
+import { BytecodeRepositoryContract } from "./bytecode-repository.js";
+import { Address, BaseError, Chain, DecodeFunctionDataReturnType, Hex, PublicClient, Transport } from "viem";
+//#region src/permissionless/bindings/kill-switch-proxy.d.ts
+declare const abi: readonly [{
+  readonly type: "constructor";
+  readonly inputs: readonly [{
+    readonly name: "_owner";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "_caller";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+  readonly stateMutability: "nonpayable";
+}, {
+  readonly type: "function";
+  readonly inputs: readonly [];
+  readonly name: "caller";
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+  readonly stateMutability: "view";
+}, {
+  readonly type: "function";
+  readonly inputs: readonly [];
+  readonly name: "contractType";
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly internalType: "bytes32";
+    readonly type: "bytes32";
+  }];
+  readonly stateMutability: "view";
+}, {
+  readonly type: "function";
+  readonly inputs: readonly [];
+  readonly name: "isKilled";
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly internalType: "bool";
+    readonly type: "bool";
+  }];
+  readonly stateMutability: "view";
+}, {
+  readonly type: "function";
+  readonly inputs: readonly [];
+  readonly name: "kill";
+  readonly outputs: readonly [];
+  readonly stateMutability: "nonpayable";
+}, {
+  readonly type: "function";
+  readonly inputs: readonly [];
+  readonly name: "owner";
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+  readonly stateMutability: "view";
+}, {
+  readonly type: "function";
+  readonly inputs: readonly [{
+    readonly name: "target";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "data";
+    readonly internalType: "bytes";
+    readonly type: "bytes";
+  }];
+  readonly name: "proxyCall";
+  readonly outputs: readonly [{
+    readonly name: "result";
+    readonly internalType: "bytes";
+    readonly type: "bytes";
+  }];
+  readonly stateMutability: "nonpayable";
+}, {
+  readonly type: "function";
+  readonly inputs: readonly [];
+  readonly name: "version";
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+  readonly stateMutability: "view";
+}, {
+  readonly type: "event";
+  readonly anonymous: false;
+  readonly inputs: readonly [];
+  readonly name: "Killed";
+}, {
+  readonly type: "error";
+  readonly inputs: readonly [{
+    readonly name: "caller";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+  readonly name: "CallerIsNotOwnerException";
+}, {
+  readonly type: "error";
+  readonly inputs: readonly [];
+  readonly name: "KilledException";
+}, {
+  readonly type: "error";
+  readonly inputs: readonly [];
+  readonly name: "OnlyCallerException";
+}, {
+  readonly type: "error";
+  readonly inputs: readonly [];
+  readonly name: "OwnerSameAsCallerException";
+}];
+/**
+ * Minor version of kill switch proxy, the latest allowed patch of it is deployed
+ */
+export declare const KILL_SWITCH_PROXY_MINOR_VERSION = 310;
+/**
+ * Salt of kill switch proxy deployed together with market configurator,
+ * makes each curator's market configurator get its own proxy
+ */
+export declare function killSwitchProxySalt(curatorName: string): Hex;
+/**
+ * Thrown when bytecode repository has no allowed kill switch proxy bytecode,
+ * so its address can't be computed and it can't be deployed
+ */
+export declare class KillSwitchProxyNotAllowedError extends BaseError {
+  name: string;
+  readonly bytecodeRepository: Address;
+  constructor(bytecodeRepository: Address);
+}
+export interface PreparedKillSwitchProxyDeployment {
+  address: Address;
+  version: number;
+  encodedParams: Hex;
+  salt: Hex;
+  isAlreadyDeployed: boolean;
+  /**
+   * Whether already deployed proxy is killed, always false for not yet deployed one
+   */
+  isKilled: boolean;
+  /**
+   * Bytecode repository `deploy` transaction, must be sent by the deployer
+   */
+  tx: RawTx;
+}
+/**
+ * Kill switch proxy forwards calls of its `caller` via `proxyCall` until `owner` kills it.
+ * It is used as market configurator's emergency admin, so that emergency powers
+ * can be revoked instantly without going through the timelock.
+ */
+export declare class KillSwitchProxyContract extends BaseContract<typeof abi> {
+  #private;
+  constructor(addr: Address, client: PublicClient<Transport, Chain>);
+  /**
+   * Encodes `constructor(address _owner, address _caller)` params
+   * @throws if any address is zero or owner equals caller (constructor reverts in that case)
+   */
+  static encodeConstructorParams(args: {
+    owner: Address;
+    caller: Address;
+  }): Hex;
+  /**
+   * Returns whether some patch of kill switch proxy v3.10 is allowed in bytecode repository
+   */
+  static isAvailable(bcr: BytecodeRepositoryContract): Promise<boolean>;
+  /**
+   * Computes address of kill switch proxy and prepares its deployment via bytecode repository
+   * @param bcr - bytecode repository
+   * @param args.deployer - address that will send deployment transaction, it is mixed into the salt
+   * @param args.owner - address that can kill the proxy
+   * @param args.caller - address that can call through the proxy
+   * @param args.salt - deployment salt
+   * @throws {KillSwitchProxyNotAllowedError} if kill switch proxy is not allowed in bytecode repository
+   */
+  static prepareDeploy(bcr: BytecodeRepositoryContract, args: {
+    deployer: Address;
+    owner: Address;
+    caller: Address;
+    salt: Hex;
+  }): Promise<PreparedKillSwitchProxyDeployment>;
+  isKilled(): Promise<boolean>;
+  state(): Promise<{
+    caller: Address;
+    owner: Address;
+    isKilled: boolean;
+  }>;
+  /**
+   * Wraps transaction into `proxyCall`, must be sent by proxy's caller
+   */
+  proxyCallTx(tx: RawTx): RawTx;
+  /**
+   * Permanently disables `proxyCall`, must be sent by proxy's owner
+   */
+  killTx(): RawTx;
+  protected parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCallArgs;
+}
+//#endregion
+export {};