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

package/dist/types/onchain/market/adapters/types.d.ts

@@ -15,7 +15,7 @@ export interface IAdapterContract extends IBaseContract {
   openingCalls(): Promise<MultiCall[]>;
 }
 export type VersionedAbi = Record<number, readonly AbiParameter[]>;
-export type AdapterContractType = "ADAPTER::ACCOUNT_MIGRATOR" | "ADAPTER::BALANCER_V3_ROUTER" | "ADAPTER::BALANCER_V3_WRAPPER" | "ADAPTER::CAMELOT_V3_ROUTER" | "ADAPTER::CURVE_STABLE_NG" | "ADAPTER::CURVE_V1_2ASSETS" | "ADAPTER::CURVE_V1_3ASSETS" | "ADAPTER::CURVE_V1_4ASSETS" | "ADAPTER::CURVE_V1_STECRV_POOL" | "ADAPTER::CVX_V1_BASE_REWARD_POOL" | "ADAPTER::CVX_V1_BOOSTER" | "ADAPTER::DAI_USDS_EXCHANGE" | "ADAPTER::ERC4626_VAULT" | "ADAPTER::ERC4626_VAULT_REFERRAL" | "ADAPTER::FLUID_DEX" | "ADAPTER::INFINIFI_GATEWAY" | "ADAPTER::INFINIFI_UNWINDING" | "ADAPTER::KELP_DEPOSIT_POOL" | "ADAPTER::KELP_WITHDRAWAL" | "ADAPTER::LIDO_V1" | "ADAPTER::LIDO_WSTETH_V1" | "ADAPTER::MELLOW_CLAIMER" | "ADAPTER::MELLOW_DVV" | "ADAPTER::MELLOW_ERC4626_VAULT" | "ADAPTER::MELLOW_WRAPPER" | "ADAPTER::MIDAS_GATEWAY" | "ADAPTER::MIDAS_ISSUANCE_VAULT" | "ADAPTER::MIDAS_REDEMPTION_VAULT" | "ADAPTER::PENDLE_ROUTER" | "ADAPTER::SECURITIZE_ONRAMP" | "ADAPTER::SECURITIZE_REDEMPTION" | "ADAPTER::STAKING_REWARDS" | "ADAPTER::TRADERJOE_ROUTER" | "ADAPTER::UNISWAP_V2_ROUTER" | "ADAPTER::UNISWAP_V3_ROUTER" | "ADAPTER::UNISWAP_V4_GATEWAY" | "ADAPTER::UPSHIFT_VAULT" | "ADAPTER::VELODROME_V2_ROUTER";
+export type AdapterContractType = "ADAPTER::ACCOUNT_MIGRATOR" | "ADAPTER::BALANCER_V3_ROUTER" | "ADAPTER::BALANCER_V3_WRAPPER" | "ADAPTER::CAMELOT_V3_ROUTER" | "ADAPTER::CURVE_STABLE_NG" | "ADAPTER::CURVE_V1_2ASSETS" | "ADAPTER::CURVE_V1_3ASSETS" | "ADAPTER::CURVE_V1_4ASSETS" | "ADAPTER::CURVE_V1_STECRV_POOL" | "ADAPTER::CVX_V1_BASE_REWARD_POOL" | "ADAPTER::CVX_V1_BOOSTER" | "ADAPTER::DAI_USDS_EXCHANGE" | "ADAPTER::ERC4626_VAULT" | "ADAPTER::ERC4626_VAULT_REFERRAL" | "ADAPTER::FLUID_DEX" | "ADAPTER::INFINIFI_GATEWAY" | "ADAPTER::INFINIFI_UNWINDING" | "ADAPTER::KELP_DEPOSIT_POOL" | "ADAPTER::KELP_WITHDRAWAL" | "ADAPTER::LIDO_V1" | "ADAPTER::LIDO_WSTETH_V1" | "ADAPTER::MELLOW_CLAIMER" | "ADAPTER::MELLOW_DVV" | "ADAPTER::MELLOW_ERC4626_VAULT" | "ADAPTER::MELLOW_WRAPPER" | "ADAPTER::MIDAS_GATEWAY" | "ADAPTER::MIDAS_ISSUANCE_VAULT" | "ADAPTER::MIDAS_REDEMPTION_VAULT" | "ADAPTER::PENDLE_ROUTER" | "ADAPTER::SECURITIZE_ONRAMP" | "ADAPTER::SECURITIZE_REDEMPTION" | "ADAPTER::STAKING_REWARDS" | "ADAPTER::TRADERJOE_ROUTER" | "ADAPTER::TREEHOUSE_FASTLANE" | "ADAPTER::TREEHOUSE_GATEWAY" | "ADAPTER::TREEHOUSE_ROUTER" | "ADAPTER::UNISWAP_V2_ROUTER" | "ADAPTER::UNISWAP_V3_ROUTER" | "ADAPTER::UNISWAP_V4_GATEWAY" | "ADAPTER::UPSHIFT_VAULT" | "ADAPTER::VELODROME_V2_ROUTER";
 export declare enum AdapterType {
   ACCOUNT_MIGRATOR = "ACCOUNT_MIGRATOR",
   BALANCER_V3_ROUTER = "BALANCER_V3_ROUTER",
@@ -50,6 +50,9 @@ export declare enum AdapterType {
   SECURITIZE_REDEMPTION = "SECURITIZE_REDEMPTION",
   STAKING_REWARDS = "STAKING_REWARDS",
   TRADERJOE_ROUTER = "TRADERJOE_ROUTER",
+  TREEHOUSE_FASTLANE = "TREEHOUSE_FASTLANE",
+  TREEHOUSE_GATEWAY = "TREEHOUSE_GATEWAY",
+  TREEHOUSE_ROUTER = "TREEHOUSE_ROUTER",
   UNISWAP_V2_ROUTER = "UNISWAP_V2_ROUTER",
   UNISWAP_V3_ROUTER = "UNISWAP_V3_ROUTER",
   UNISWAP_V4_GATEWAY = "UNISWAP_V4_GATEWAY",

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 { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./oracles/types.js";
+import { AssetScore, AssetScoresArgs, 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 { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, ScoreSource, scoreMarket } 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, 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, AttachChainsArgs, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, ForbidFeedsArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GetPricesArgs, InstanceOwnerTransactions, InstanceTxsArgs, PermissionlessAnalytics, PermissionlessAsset, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PreparedDeployment, PreparedPriceFeedDeployment, PriceChartArgs, PriceFeedArgs, PriceFeedChartPoint, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedPriceChart, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };
+export { AddFeedsArgs, AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, AttachChainsArgs, BOUND_WEIGHT, 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, GroupReport, GroupScenarioOutcome, INDEPENDENCE_WEIGHT, 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, ScoreSource, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, deriveEffectiveStalenessPeriod, groupOverride, perturb, priceFeedSalt, rateStub, readForest, readRateTargets, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreMarket, slotHarm, sourcesByFeed, verdictOf };

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

@@ -2,8 +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 { GetPricesArgs, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./types.js";
-import { Address } from "viem";
+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;
@@ -13,9 +14,17 @@ export declare const GET_PRICES_CHUNK_SIZE = 200;
  *
  * ```ts
  * const store = await permissionless.oracles.store({ chainId: 1 });
- * const { prices } = await permissionless.oracles.prices({ chainId: 1 });
+ * const prices = await permissionless.oracles.getPrices(
+ *   store.priceFeeds.map(({ address }) => ({ chainId: 1, address })),
+ * );
  * ```
  *
+ * The backend answers what it has indexed; anything that is only true at a
+ * block — a price, a market cap, a quota in one currency, the period an
+ * oracle holds for a slot — is read here, off the chain, and folded into what
+ * it answered. That is why these reads mix a request with a multicall rather
+ * than being either one.
+ *
  * Read-only. What the store carries is decided on chain, so putting a feed
  * there is a batch the instance owner executes — see
  * {@link InstanceOwnerTransactions} — not a row a client writes here.
@@ -25,10 +34,52 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
   constructor(options: GearboxPermissionlessOptions, chains: ChainsNamespace);
   /**
    * The store with the assets and feeds of one chain.
+   *
+   * {@link stores} narrowed to one and unwrapped, which is the whole of it:
+   * there is one route either way, and a chain the backend does not serve has
+   * no store to answer with rather than an empty one.
+   *
+   * @throws When the backend serves no store for the chain.
    **/
   store({ chainId }: {
     chainId: number;
   }): Promise<PermissionlessPriceFeedStore>;
+  /**
+   * The same stores for every chain the backend serves.
+   *
+   * One request rather than {@link store} per chain, which is what a page
+   * showing all of them would otherwise do: the backend assembles them in the
+   * same few queries it assembles one in, so the chains cost little more than
+   * the largest of them.
+   *
+   * Each entry names its own chain, so a store is never attributed by
+   * position. `chainId` narrows it to one, for a caller that wants the list
+   * shape either way.
+   *
+   * ```ts
+   * const stores = await permissionless.oracles.stores();
+   * ```
+   **/
+  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.
@@ -44,10 +95,127 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * });
    * ```
    *
+   * Each market row also carries the staleness period that market's own
+   * oracle holds for the slot, read off the chain here — see
+   * {@link PermissionlessPriceFeedMarket.marketStalenessPeriod}.
+   *
    * @throws When the store does not carry the feed. A private draft is not
    * here — it lives in whichever app wrote it.
    **/
   feed({ chainId, address }: PriceFeedArgs): Promise<PermissionlessPriceFeedDetails>;
+  /**
+   * One asset of the store: the feeds allowed for it, and the markets that
+   * take it as collateral.
+   *
+   * The mirror of {@link feed}, and the call to reach for when the question is
+   * "what prices this token and what is it backing" rather than "where is this
+   * feed used". Both read the same market slots; which end they are indexed
+   * from is the difference.
+   *
+   * ```ts
+   * const { priceFeeds, markets, quotaUsedUsd } =
+   *   await permissionless.oracles.asset({ chainId: 1, address: token });
+   * ```
+   *
+   * The quota totals are worked out here, over the very market rows this
+   * answers with — see {@link PermissionlessQuotaTotals}.
+   *
+   * @throws When the chain has no metadata for the address. An asset nothing
+   * was indexed for has no symbol or decimals, so there is no row to answer.
+   **/
+  asset({ chainId, address }: AssetArgs): Promise<PermissionlessAssetDetails>;
+  /**
+   * Every asset the store carries, with what its markets make of it.
+   *
+   * Enough on its own to render a list of assets: the alternative is the
+   * store's whole read for the names plus a call per row for the quotas, and
+   * this is one request either way you scope it.
+   *
+   * Ordered by how central each asset is — the markets it underlies first,
+   * then what is quoted against it, then what it is allowed — so a consumer
+   * renders the rows as they arrive. Omit `chainId` for every chain the
+   * backend serves, ordered the same way across all of them.
+   *
+   * Each row also carries its quota totals and what this SDK's tables say the
+   * asset is, neither of which is served — see
+   * {@link PermissionlessAssetSummary}. The totals are what the last two terms
+   * of the order are over, so this waits for them rather than handing back a
+   * list that would reshuffle a moment later.
+   *
+   * ```ts
+   * const assets = await permissionless.oracles.assets({ chainId: 1 });
+   * const everywhere = await permissionless.oracles.assets();
+   * ```
+   **/
+  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.
+   *
+   * A market scores 10 when its reserve feed is a second feed on other
+   * sources than the main one, and one of the two is bounded — a
+   * `BoundedPriceFeed` or a Gearbox LP feed. It loses 6 points as the two
+   * feeds' sources overlap — all of them if there is no reserve, it is a
+   * `ZeroPriceFeed`, or it is the main feed again — and 5 if neither is
+   * bounded. An asset scores its worst running market that takes it as
+   * collateral.
+   *
+   * Read off the chain, one multicall of feed trees per chain, so the score
+   * is of the trees as they stand rather than as last indexed. A chain with
+   * no client configured 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.
    *
@@ -64,54 +232,83 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    **/
   dependencies({ chainId, address }: PriceFeedArgs): Promise<PriceFeedData>;
   /**
-   * What the market values each of one feed's assets at.
+   * What the named feeds price, read off the chain.
+   *
+   * Prices exactly what is asked for, at the current block, across as many
+   * chains as the list names — one read per chain, so a screen listing every
+   * chain's feeds pays per chain and not per row. A feed the store does not
+   * carry prices the same way, which is what makes this the call to reach for
+   * after a deploy, or while a form is still choosing between candidates.
+   *
+   * Read in two passes. The first asks every feed what it reports as it
+   * stands, which is one multicall per chain; a feed that will not answer
+   * until it has been given a fresh one is then priced inside a simulation
+   * that updates it first, so a push-based feed prices as readily as a
+   * pull-based one. The second pass costs an `OnchainSDK` to attach, hence
+   * only the feeds that need it rather than all of them.
    *
-   * Prefer this over {@link prices} whenever the caller is looking at a single
-   * feed. That one prices the whole store, which costs the backend one
-   * `totalSupply` call per asset of every market on the chain; this costs it
-   * one price lookup and one multicall over the feed's own assets.
+   * `null` is a feed neither pass could read, and a chain with no client
+   * configured is every one of its feeds reading `null` rather than a failed
+   * call — the figures built on them are floors either way.
    *
    * ```ts
-   * const { marketCaps } = await permissionless.oracles.feedMarketCaps({
-   *   chainId: 1,
-   *   address: feed,
-   * });
+   * const [{ price }] = await permissionless.oracles.getPrices([
+   *   { chainId: 1, address: feed },
+   * ]);
    * ```
+   *
+   * @returns One entry per feed asked for, in the order asked, each price in
+   * the 8 decimals every Gearbox feed reports.
    **/
-  feedMarketCaps({ chainId, address }: PriceFeedArgs): Promise<PermissionlessPriceFeedMarketCaps>;
+  getPrices(feeds: PriceFeedRef[]): Promise<PriceFeedPrice[]>;
   /**
-   * A price per feed, and a market cap per feed and asset. The feeds the
-   * indexer has not seen are read off the chain by the backend, so the store
-   * is priced whole.
+   * The scale each of the named feeds answers in.
    *
-   * Chain-wide, and priced accordingly — see {@link feedMarketCaps} for one
-   * feed.
+   * 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.
    **/
-  prices({ chainId }: {
-    chainId: number;
-  }): Promise<PermissionlessPrices>;
+  getDecimals(feeds: PriceFeedRef[]): Promise<PriceFeedDecimals[]>;
   /**
-   * The price each of the named feeds reports, read off the chain.
+   * What one chain's feeds value one chain's assets at: `price × totalSupply`
+   * per pair.
    *
-   * Where {@link prices} answers for the store as a whole and at whatever
-   * moment the backend priced it, this prices exactly the feeds asked for, at
-   * the current block. A feed the store does not carry prices the same way,
-   * which is what makes this the call to reach for after a deploy, or while a
-   * form is still choosing between candidates.
+   * Asked from whichever side the caller is looking at — one asset through
+   * each of its feeds, or one feed over each of the assets it prices — because
+   * a screen shows one row per feed or one row per asset, never the full
+   * cross product. Both answer the same pairs in the same shape.
    *
-   * Feeds needing a fresh answer before they can be read are updated inside
-   * the same simulation, so a push-based feed prices as readily as a
-   * pull-based one. `null` is a feed whose read reverted, not a zero.
+   * Two reads per chain: the prices, and one multicall for the assets'
+   * supplies and decimals. Several scopes can be asked at once, which is how a
+   * table of every asset's feeds pays per chain rather than per row; the pairs
+   * come back in the order the scopes named them. A pair neither read could
+   * resolve has a `null` cap, which is not a zero.
    *
    * ```ts
-   * const prices = await permissionless.oracles.getPrices({
+   * const caps = await permissionless.oracles.getMarketCap({
    *   chainId: 1,
-   *   priceFeeds: [feed],
+   *   asset: token,
+   *   priceFeeds: [main, reserve],
    * });
    * ```
-   *
-   * @returns A price per feed, in the 8 decimals every Gearbox feed reports.
    **/
-  getPrices({ chainId, priceFeeds }: GetPricesArgs): Promise<Record<Address, bigint | null>>;
+  getMarketCap(scope: AssetCap | FeedCap | Array<AssetCap | FeedCap>): Promise<MarketCap[]>;
 }
 //#endregion

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

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

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

@@ -1,3 +1,13 @@
-import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./types.js";
+import { AssetScore, AssetScoresArgs, 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 { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GetPricesArgs, PermissionlessAsset, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs };
+import { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, ScoreSource, scoreMarket } 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, runStressTest } from "./stress/run.js";
+import { scoreGroup, slotHarm, verdictOf } from "./stress/score.js";
+import "./stress/index.js";
+export { AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, BOUND_WEIGHT, BreakingPoint, DEFAULT_SCENARIOS, FeedCap, FeedOutcome, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GroupReport, GroupScenarioOutcome, INDEPENDENCE_WEIGHT, 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, ScoreSource, ScoredFeed, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, classifySources, groupOverride, perturb, rateStub, readForest, readRateTargets, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreMarket, slotHarm, sourcesByFeed, verdictOf };