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

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

@@ -1,62 +1,53 @@
+import { AssetType } from "../../../model/primitives.js";
+import { PermissionlessChain } from "../chains/types.js";
 import { PriceFeed } from "../../core/pricefeed.js";
 import "../../core/index.js";
 import { Address } from "viem";
 //#region src/permissionless/api/oracles/types.d.ts
 /**
- * One asset of a chain, with the feeds allowed for it. The backend indexes
- * the chain, so every feed listed here is one the PriceFeedStore carries and
- * allows for the asset.
+ * What identifies an asset, which is all a feed's own listing of one says.
+ *
+ * Used on its own where the asset hangs off something else — a feed's assets,
+ * say, where listing the feeds allowed for each would only name the feed back.
  **/
-export interface PermissionlessAsset {
+export interface PermissionlessPriceFeedAsset {
   address: Address;
   symbol: string;
   name: string;
   decimals: number;
+}
+/**
+ * One asset of a chain, with the feeds allowed for it. The backend indexes
+ * the chain, so every feed listed here is one the PriceFeedStore carries and
+ * allows for the asset.
+ **/
+export interface PermissionlessAsset extends PermissionlessPriceFeedAsset {
   owner: Address;
   priceFeeds: PriceFeed[];
 }
 /**
  * The PriceFeedStore of one chain as the backend has indexed it: the assets
  * it prices, the feeds it carries, and which feed is allowed on which asset.
+ *
+ * A store is a chain's, so it is described by the same fields the chain list
+ * answers with, plus what it holds.
  **/
-export interface PermissionlessPriceFeedStore {
-  chainId: number;
-  name: string;
-  isPublic: boolean;
-  isActivated: boolean;
-  explorerUrl: string;
+export interface PermissionlessPriceFeedStore extends PermissionlessChain {
   assets: PermissionlessAsset[];
   priceFeeds: PriceFeed[];
 }
 /**
- * A price per feed, and a market cap per feed and the asset it prices.
- * `null` is a price the backend could not read, not a zero.
- **/
-export interface PermissionlessPrices {
-  prices: Record<Address, string | null>;
-  marketCaps: Record<Address, Record<Address, string | null>>;
-  time: number;
-}
-/**
- * An asset the PriceFeedStore currently allows one feed to price.
+ * What names a market, whichever side it is being listed from.
  *
- * Narrower than {@link PermissionlessAsset} on purpose: this hangs off the
- * feed, so listing the feeds allowed for it would just name the feed back.
- **/
-export interface PermissionlessPriceFeedAsset {
-  address: Address;
-  symbol: string;
-  name: string;
-  decimals: number;
-}
-/**
- * One token a market prices with the feed.
+ * A feed's markets and an asset's markets are different reads, but what they
+ * say about the market is the same: who curates it, what it is denominated in
+ * and how much of its quota is taken. Only the thing the row is about differs,
+ * which is what each of the two below adds.
  *
- * A row per `(market, token, role)` rather than per market: the same feed can
- * be the main feed of one token and the reserve feed of another in the very
- * same market, and both are reported.
+ * "This token" throughout means whatever the extending row is about — the
+ * token the feed prices, or the asset the market holds as collateral.
  **/
-export interface PermissionlessPriceFeedMarket {
+export interface PermissionlessMarket {
   market: Address;
   marketConfigurator: Address;
   /** The configurator's own name, as the backend's sync recorded it. */
@@ -66,17 +57,12 @@ export interface PermissionlessPriceFeedMarket {
    * of the backend calls a market by as well.
    */
   marketName: string | null;
-  token: Address;
-  /** `null` for a token the backend has no metadata row for. */
-  tokenSymbol: string | null;
   /**
    * Symbol of the market's underlying, which is both what the market is
-   * pictured by and what its quota limit is denominated in.
+   * pictured by and what its quota figures are denominated in.
    */
   underlyingSymbol: string | null;
-  /** The feed is the market's reserve feed for this token, not its main one. */
-  reserve: boolean;
-  /** The token is the market's underlying. */
+  /** This token is the market's own underlying, so it is not quota-managed. */
   isUnderlying: boolean;
   /**
    * What the pool will take of this token, in units of the market's
@@ -88,6 +74,98 @@ export interface PermissionlessPriceFeedMarket {
    * answers.
    */
   quotaLimit: number | null;
+  /**
+   * How much of {@link quotaLimit} the market's borrowers have actually taken,
+   * in the same units.
+   *
+   * The sum of every open credit account's current quota for this token across
+   * the credit managers borrowing from the market, so it is what the token is
+   * backing right now rather than what it is allowed to back.
+   *
+   * `null` only where {@link quotaLimit} is: a token nobody quotes reads as a
+   * zero against a limit, which is a different answer from a token the keeper
+   * holds no entry for at all.
+   */
+  quotaUsed: number | null;
+}
+/**
+ * One token a market prices with the feed.
+ *
+ * A row per `(market, token, role)` rather than per market: the same feed can
+ * be the main feed of one token and the reserve feed of another in the very
+ * same market, and both are reported.
+ **/
+export interface PermissionlessIndexedPriceFeedMarket extends PermissionlessMarket {
+  token: Address;
+  /** `null` for a token the backend has no metadata row for. */
+  tokenSymbol: string | null;
+  /** The feed is the market's reserve feed for this token, not its main one. */
+  reserve: boolean;
+  /**
+   * The price oracle holding the slot, which is what the period is read from.
+   *
+   * The oracle and not the market: a market that has switched oracles has
+   * rows under each, and the period lives on whichever one holds the slot now.
+   */
+  priceOracle: Address;
+}
+/**
+ * The same slot with the period its oracle holds for it.
+ *
+ * Read off the chain rather than served, because it is not indexed: a
+ * curator sets one per slot in their price oracle, and nothing obliges it to
+ * agree with the period the PriceFeedStore carries for the feed. A reader
+ * comparing the two is comparing two contracts, which is why both are
+ * reported.
+ **/
+export interface PermissionlessPriceFeedMarket extends PermissionlessIndexedPriceFeedMarket {
+  /**
+   * Staleness period this market's own price oracle holds for the slot, in
+   * seconds.
+   *
+   * `null` means the oracle would not answer, or that it names another feed
+   * for the slot — in which case the slot has moved on since it was indexed
+   * and the period it holds is not this feed's to report.
+   */
+  marketStalenessPeriod: number | null;
+}
+/**
+ * One `(market, token, role)` slot of a chain, with the feed holding it.
+ *
+ * The same row {@link PermissionlessIndexedPriceFeedMarket} is, read from the
+ * chain's end rather than from one feed's: the feed is a column here because
+ * it is no longer what was asked for, and the chain is named because the read
+ * spans several.
+ *
+ * Unpivoted — a token's main and reserve feeds are two rows. What reads them
+ * this way is analysis over every slot at once, where the two roles of a
+ * token are the pair being compared and folding them together would hide it.
+ **/
+export interface PermissionlessMarketSlot extends PermissionlessIndexedPriceFeedMarket {
+  chainId: number;
+  /** The market's underlying, which its quota figures are denominated in. */
+  underlyingToken: Address;
+  /**
+   * The market has been shut down: no new borrowing, but its open accounts
+   * are quoting all the same.
+   */
+  isShutdown: boolean;
+  /** The feed in force for the slot. */
+  priceFeed: Address;
+  /** Display name the store recorded, or `null` for a feed it never had. */
+  priceFeedName: string | null;
+  /**
+   * Whether the PriceFeedStore still carries that feed.
+   *
+   * `false` is the case worth looking at: the market goes on pricing with
+   * something the store has removed, or never had.
+   */
+  priceFeedInStore: boolean;
+  /**
+   * The feed the market prices its own underlying with, which is what
+   * converts this row's quota figures. `null` for a market that has none.
+   */
+  underlyingPriceFeed: Address | null;
 }
 /**
  * One feed of the store, with everywhere the store lets it be used.
@@ -96,7 +174,7 @@ export interface PermissionlessPriceFeedMarket {
  * no status history, hence no name or staleness — so the read throws for them
  * rather than answering a half-filled row.
  **/
-export interface PermissionlessPriceFeedDetails {
+export interface PermissionlessIndexedPriceFeedDetails {
   chainId: number;
   priceFeed: PriceFeed;
   assets: PermissionlessPriceFeedAsset[];
@@ -105,38 +183,305 @@ export interface PermissionlessPriceFeedDetails {
    * ahead of the reserve ones — the grouping a reader wants, so a caller
    * rendering a table does not have to sort it again.
    */
+  markets: PermissionlessIndexedPriceFeedMarket[];
+}
+/**
+ * The same feed with each slot's staleness period read off its oracle.
+ **/
+export interface PermissionlessPriceFeedDetails extends PermissionlessIndexedPriceFeedDetails {
   markets: PermissionlessPriceFeedMarket[];
 }
 /**
- * Market caps of one feed's assets, keyed by the lowercased asset address.
+ * One feed as a market slot holds it.
  *
- * Scoped to the feed rather than to the chain, which is what
- * {@link PermissionlessOracles.prices} answers. A cap is
- * `price × totalSupply`, so the chain-wide read pays for one `totalSupply` per
- * asset of every market on it; a screen showing one feed's handful of rows
- * should not.
+ * The store's view of the feed and not the feed itself: a market keeps
+ * pricing with whatever it was last pointed at, and nothing removes it from a
+ * market when the store drops it. {@link inStore} is what tells those apart,
+ * and the name survives either way because the store recorded it before.
+ **/
+export interface PermissionlessAssetMarketFeed {
+  address: Address;
+  /**
+   * Display name the store recorded, or `null` for a feed it never carried —
+   * an aggregator a curator pointed a market straight at, say.
+   */
+  name: string | null;
+  /**
+   * Whether the PriceFeedStore still carries the feed.
+   *
+   * `false` is the case worth showing: the market goes on pricing the asset
+   * with a feed the store has removed, or never had. Nothing on chain forbids
+   * that, which is exactly why it has to be visible.
+   */
+  inStore: boolean;
+}
+/**
+ * One market that prices an asset, with both of the slots it may fill.
  *
- * `null` for an asset whose price or supply could not be read — not a zero,
+ * A row per market rather than per `(market, role)`: the two roles are two
+ * columns of the same market's row, and the quota is the market's whatever
+ * feed holds which slot.
+ **/
+export interface PermissionlessAssetMarket extends PermissionlessMarket {
+  /** The market's underlying, which its quota figures are denominated in. */
+  underlyingToken: Address;
+  /**
+   * The feed the market prices its own underlying with, which is what converts
+   * this row's quota figures. `null` for a market that has no main feed for
+   * its underlying, whose figures therefore cannot be converted at all.
+   */
+  underlyingPriceFeed: Address | null;
+  /**
+   * The market has been shut down.
+   *
+   * Still reported, and still counted in {@link
+   * PermissionlessQuotaTotals.quotaUsedUsd}: a shut down market carries no
+   * new borrowing but its open accounts are quoting all the same.
+   */
+  isShutdown: boolean;
+  /** The feed the market prices the asset with, or `null` if it has none. */
+  mainFeed: PermissionlessAssetMarketFeed | null;
+  /** The feed the market falls back to, or `null` if it has none. */
+  reserveFeed: PermissionlessAssetMarketFeed | null;
+}
+/**
+ * One asset of the store: what prices it, and what it is used as collateral
+ * for.
+ *
+ * The counterpart of {@link PermissionlessPriceFeedDetails} — the same corner
+ * of the chain read from the asset's end instead of the feed's.
+ **/
+export interface PermissionlessIndexedAssetDetails {
+  chainId: number;
+  asset: PermissionlessPriceFeedAsset;
+  /**
+   * Feeds the store currently allows for the asset.
+   *
+   * Only the store's. A feed a market still prices the asset with but the
+   * store has dropped is not here — it is on its market's row, flagged.
+   */
+  priceFeeds: PriceFeed[];
+  /** Ordered by curator, then by market. */
+  markets: PermissionlessAssetMarket[];
+}
+/**
+ * The same asset with its quotas totalled, which is what a reader gets.
+ *
+ * The totals are over the very rows {@link markets} reports, converted at the
+ * price each market's own oracle holds for its underlying, so the header and
+ * the table under it cannot disagree.
+ **/
+export interface PermissionlessAssetDetails extends PermissionlessIndexedAssetDetails, PermissionlessQuotaTotals {}
+/**
+ * One asset of the PriceFeedStore, with what its markets make of it.
+ *
+ * Everything a list of assets renders and nothing else: the store's own read
+ * carries each asset's feeds too, which is several times this payload and not
+ * what a reader scanning for the big positions is looking at.
+ *
+ * The quota rows are the ones {@link PermissionlessAssetDetails} heads an
+ * asset's own page with, off the same query, so the list and the page a row of
+ * it opens are totalling the very same figures.
+ *
+ * What a reader gets is {@link PermissionlessAssetSummary}, this plus what the
+ * SDK makes of the asset.
+ **/
+export interface PermissionlessIndexedAssetSummary {
+  chainId: number;
+  /** Lowercased, as everything addressed in these payloads is. */
+  address: Address;
+  symbol: string;
+  /**
+   * How many markets still running are underlain by this asset.
+   *
+   * What makes an asset central rather than merely listed: a token several
+   * markets borrow against is the one a reader opens the list for. Shut down
+   * markets are left out for the reason their limits are — they are no longer
+   * a place anything happens.
+   */
+  underlyingMarketCount: number;
+  /**
+   * What each market holding the asset has committed to it, unconverted.
+   *
+   * One entry per market, in that market's own underlying — see
+   * {@link PermissionlessAssetQuota}. Totalling them is
+   * {@link PermissionlessAssetSummary}'s two USD figures, which is why they
+   * are carried rather than summed: the sum needs a price, and a price needs
+   * the chain.
+   */
+  marketQuotas: PermissionlessAssetQuota[];
+}
+/**
+ * One market's commitment to an asset, in that market's own underlying.
+ *
+ * Unconverted on purpose: a limit is denominated in its market's underlying,
+ * and an asset is routinely collateral in markets underlain by different
+ * tokens — WETH is collateral in USDC, WETH and wstETH markets at once on
+ * mainnet — so the figures are not comparable until each is priced. The feed
+ * that prices the underlying is named here so that whoever totals them knows
+ * what to ask the chain.
+ **/
+export interface PermissionlessAssetQuota {
+  /**
+   * What the pool will take of the asset, in units of the market's underlying.
+   *
+   * `null` for a token the quota keeper was never told a limit for, which the
+   * market's own underlying always is — it is not quota-managed. A zero is a
+   * limit the curator has actually set to zero, and the two are different
+   * answers.
+   */
+  quotaLimit: number | null;
+  /** How much of that limit is taken, in the same units. */
+  quotaUsed: number | null;
+  /** The market has been shut down, so its limit is no longer borrowable. */
+  isShutdown: boolean;
+  /**
+   * The feed the market prices its own underlying with.
+   *
+   * `null` for a market with no main feed for its underlying, whose figures
+   * therefore cannot be converted at all.
+   */
+  underlyingPriceFeed: Address | null;
+}
+/**
+ * Totals of {@link PermissionlessAssetQuota}, converted to USD.
+ *
+ * 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.
+ **/
+export interface PermissionlessQuotaTotals {
+  /** Total quota limit across the markets still running, in USD. */
+  quotaLimitUsd: number | null;
+  /** Total quota actually taken across every market, in USD. */
+  quotaUsedUsd: number | null;
+}
+/**
+ * The same asset with what this SDK makes of it.
+ *
+ * Two things the backend does not answer for. What the asset is comes off this
+ * package's curated tables, because a backend consulting them could only
+ * answer from whichever version it was built against — a reader on a newer SDK
+ * than the deployment it talks to still classifies by the newer tables. The
+ * quota totals come off the chain, because converting a market's own
+ * denomination needs a price and the chain is where prices are.
+ **/
+export interface PermissionlessAssetSummary extends PermissionlessIndexedAssetSummary, PermissionlessQuotaTotals {
+  /**
+   * What the asset is, where the tables say so.
+   *
+   * `null` for anything they do not name, which is most of a store: they
+   * classify the tokens markets are built on, and a store carries everything
+   * those markets will take as collateral. A filter over this sorts the
+   * assets worth sorting and leaves the rest in one heap, which is the honest
+   * answer rather than a guess from the symbol.
+   */
+  assetType: AssetType | null;
+  /**
+   * Whether the asset stands for something outside the chain.
+   *
+   * A flag rather than a value of {@link assetType}, because the two answer
+   * different questions and an asset can be both: a tokenised treasury is a
+   * real-world asset and may still be the stable a market is built on. Unlike
+   * {@link assetType} there is no third state — the curated list naming it is
+   * the whole of what makes an asset one, so not being on it is a real `false`
+   * rather than something unknown.
+   */
+  isRwa: boolean;
+}
+/**
+ * One feed of a chain, named so it can be read alongside another chain's.
+ *
+ * An address alone does not identify a feed: the same aggregator is deployed
+ * to several chains, and reading it on the wrong one answers the wrong price.
+ **/
+export interface PriceFeedRef {
+  chainId: number;
+  address: Address;
+}
+/**
+ * The price one feed reports, as {@link PermissionlessOracles.getPrices}
+ * answers.
+ *
+ * `price` is `null` for a feed whose read reverted, which is not a zero, and
+ * is in the 8 decimals every Gearbox feed reports.
+ **/
+export interface PriceFeedPrice extends PriceFeedRef {
+  price: bigint | null;
+}
+/**
+ * How many decimals a feed's answer carries, as
+ * {@link PermissionlessOracles.getDecimals} answers.
+ *
+ * Its own call rather than a field of {@link PriceFeedPrice}, because the two
+ * are not read on the same schedule: a price is the figure that moves and is
+ * re-read for it, while a deployed feed's decimals never change, so a caller
+ * reads these once and keeps them.
+ *
+ * Needed wherever the feeds are not only the ones a market reads. Every
+ * Gearbox feed an oracle holds reports 8, which is why most of this namespace
+ * can assume it — but a composite's own dependencies are whatever the
+ * aggregator underneath happens to be, and a rate leg of one is routinely 18.
+ *
+ * `null` is a feed that would not answer `decimals()` at all, which a caller
+ * showing the figure should treat as unknown rather than as 8.
+ **/
+export interface PriceFeedDecimals extends PriceFeedRef {
+  decimals: number | null;
+}
+/**
+ * One asset with the feeds to value it through.
+ *
+ * The asset's side of {@link PermissionlessOracles.getMarketCap} — the shape a
+ * screen showing one asset's feeds asks with.
+ **/
+export interface AssetCap {
+  chainId: number;
+  asset: Address;
+  priceFeeds: Address[];
+}
+/**
+ * One feed with the assets to value through it.
+ *
+ * The feed's side of the same call. Both exist because a screen shows one row
+ * per feed or one row per asset, never the full cross product.
+ **/
+export interface FeedCap {
+  chainId: number;
+  priceFeed: Address;
+  assets: Address[];
+}
+/**
+ * What one feed values one asset's supply at, in USD.
+ *
+ * `price × totalSupply`, as a decimal string: the product of an 8-decimal
+ * price and a supply in the asset's own decimals does not fit a JS number
+ * without losing the small end of it.
+ *
+ * `null` for a pair whose price or supply could not be read — not a zero,
  * since an asset nobody could price is not an asset worth nothing.
- */
-export interface PermissionlessPriceFeedMarketCaps {
-  marketCaps: Record<Address, string | null>;
-  /** When the backend computed the figures; they are read live, not indexed. */
-  time: number;
+ **/
+export interface MarketCap {
+  chainId: number;
+  priceFeed: Address;
+  asset: Address;
+  cap: string | null;
 }
 /** Args of a read scoped to one feed. */
 export interface PriceFeedArgs {
   chainId: number;
   address: Address;
 }
-/** Args of {@link PermissionlessOracles.getPrices}. */
-export interface GetPricesArgs {
+/** Args of a read scoped to one asset. */
+export interface AssetArgs {
   chainId: number;
-  /**
-   * The feeds to price. Any address answering `latestRoundData` works — the
-   * store does not have to carry it, which is the point of reading the chain
-   * rather than asking the backend.
-   **/
-  priceFeeds: Address[];
+  address: Address;
+}
+/** Args of {@link PermissionlessOracles.assets}. */
+export interface AssetsArgs {
+  /** Omit for every chain the backend serves. */
+  chainId?: number;
 }
 //#endregion

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

@@ -11,8 +11,6 @@ import { z } from "zod/v4";
  **/
 /** An address, in whatever case the backend serves it. */
 export declare const addressSchema: z.ZodCustom<`0x${string}`, `0x${string}`>;
-/** A `0x`-prefixed hex string, as viem's `Hex`. */
-export declare const hexSchema: z.ZodCustom<`0x${string}`, `0x${string}`>;
 /**
  * A record keyed by address. Spelled out here because zod types a record key
  * by the schema's output, which the branded `Address` is not inferred as.

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

@@ -13,7 +13,9 @@ import "./core/index.js";
 import { FunctionParams, ValueParams, encodeFunctionParams } from "./utils/abi-encoder.js";
 import { DeployArgs, DeployContractArgs, DeployPriceFeedArgs, PreparedDeployment, PreparedPriceFeedDeployment } from "./api/deploy/types.js";
 import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./api/deploy/PermissionlessDeploy.js";
-import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./api/oracles/types.js";
+import { AssetScore, AssetScoresArgs, MarketScore, ScoredFeed } from "./api/oracles/score/types.js";
+import { BreakingPoint, FeedOutcome, GroupReport, GroupScenarioOutcome, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs } from "./api/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 "./api/oracles/types.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./api/oracles/PermissionlessOracles.js";
 import { AddressProviderContract } from "./bindings/address-provider.js";
 import { BytecodeRepositoryContract } from "./bindings/bytecode-repository.js";
@@ -38,6 +40,12 @@ import { InstanceOwnerTransactions } from "./api/transactions/InstanceOwnerTrans
 import { GearboxPermissionless } from "./api/GearboxPermissionless.js";
 import { deriveEffectiveStalenessPeriod } from "./api/deploy/effective-staleness.js";
 import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./api/errors.js";
+import { BOUND_WEIGHT, INDEPENDENCE_WEIGHT, ScoreSource, scoreMarket } from "./api/oracles/score/formula.js";
+import { runAssetScores } from "./api/oracles/score/run.js";
+import { TreeNode, classifySources, sourcesByFeed } from "./api/oracles/stress/classify.js";
+import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./api/oracles/stress/override.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readForest, readRateTargets, runStressTest } from "./api/oracles/stress/run.js";
+import { scoreGroup, slotHarm, verdictOf } from "./api/oracles/stress/score.js";
 import "./api/index.js";
 import { ArchiveTransport, ArchiveTransportConfig } from "./chains/archive-transport.js";
 import { chunkedLogsTransport } from "./chains/chunked-log-transport.js";
@@ -50,8 +58,8 @@ import { calculateChecksum, convertRawTxToSafeMultisigTx, getSafeBatch, getSafeB
 import { convertQueueBatchToExecuteTx } from "./utils/governance/timelock-txs.js";
 import { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, TOKEN_COMPRESSOR } from "./utils/literals.js";
 import { getPriceUpdateTx } from "./utils/price-update/get-price-update-tx.js";
-import { getPrices } from "./utils/price-update/get-prices.js";
+import { getFeedDecimals, getLatestPrices, getPrices } from "./utils/price-update/get-prices.js";
 import { GetUpdatablePriceFeedsArgs, getUpdatablePriceFeeds } from "./utils/price-update/get-updatable-feeds.js";
 import { normalizeSignature } from "./utils/signature.js";
 import "./utils/index.js";
-export { AccessMode, AddAssetParams, AddFeedsArgs, AddressProviderContract, Addresses, AllowTokenParams, ArchiveTransport, ArchiveTransportConfig, AttachChainsArgs, AuditEvent, Auditor, BYTECODE_REPOSITORY, Batch, Bytecode, BytecodeRepositoryContract, CCMConstructorParams, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ConstructorParams, CreditManagerFees, CrossChainCall, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployParams, DeployPriceFeedArgs, Deployment, DeploymentExtended, ForbidAdapterParams, ForbidFeedsArgs, ForbidTokenParams, FunctionParams, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GetPricesArgs, GetUpdatablePriceFeedsArgs, GovernorContract, INSTANCE_MANAGER, InputValueParams, InstanceManagerContract, InstanceOwnerTransactions, InstanceTxs, InstanceTxsArgs, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, Market, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PauseCreditManagerParams, PeripheryDomain, PermissionlessAnalytics, PermissionlessAsset, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PreparedDeployment, PreparedPriceFeedDeployment, PriceChartArgs, PriceFeed, PriceFeedArgs, PriceFeedChartPoint, PriceFeedConstructorParam, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedParamType, PriceFeedParams, PriceFeedPriceChart, PriceFeedSaltMissingError, PriceFeedSetupParams, PriceFeedStalenessUnknownError, PriceFeedStoreContract, Proposal, QueuedAndExecutedTransaction, RecoveryMessage, RoutingManagerContract, SafeBatch, SafeMeta, SafeTx, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, Signature, TOKEN_COMPRESSOR, TimeLockContract, TimelockTransaction, TimelockTxParams, TimelockTxs, TokenCompressorContract, TreasurySplitterContract, UnpauseCreditManagerParams, ValueParams, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, priceFeedSalt, priceFeedSetupParams, shortenHash, significantTrunc };
+export { AccessMode, AddAssetParams, AddFeedsArgs, AddressProviderContract, Addresses, AllowTokenParams, ArchiveTransport, ArchiveTransportConfig, AssetArgs, AssetCap, AssetScore, AssetScoresArgs, AssetsArgs, AttachChainsArgs, AuditEvent, Auditor, BOUND_WEIGHT, BYTECODE_REPOSITORY, Batch, BreakingPoint, Bytecode, BytecodeRepositoryContract, CCMConstructorParams, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ConstructorParams, CreditManagerFees, CrossChainCall, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, DeployArgs, DeployContractArgs, DeployParams, DeployPriceFeedArgs, Deployment, DeploymentExtended, FeedCap, FeedOutcome, ForbidAdapterParams, ForbidFeedsArgs, ForbidTokenParams, FunctionParams, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GetUpdatablePriceFeedsArgs, GovernorContract, GroupReport, GroupScenarioOutcome, INDEPENDENCE_WEIGHT, INSTANCE_MANAGER, InputValueParams, InstanceManagerContract, InstanceOwnerTransactions, InstanceTxs, InstanceTxsArgs, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, Market, MarketCap, MarketConfiguratorContract, MarketConfiguratorFactoryContract, MarketScore, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PauseCreditManagerParams, PeripheryDomain, 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, PriceFeed, PriceFeedArgs, PriceFeedChartPoint, PriceFeedConstructorParam, PriceFeedDecimals, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedParamType, PriceFeedParams, PriceFeedPrice, PriceFeedPriceChart, PriceFeedRef, PriceFeedSaltMissingError, PriceFeedSetupParams, PriceFeedStalenessUnknownError, PriceFeedStoreContract, Proposal, QueuedAndExecutedTransaction, RATE_FEED_TYPE, RecoveryMessage, RoutingManagerContract, SafeBatch, SafeMeta, SafeTx, ScoreSource, ScoredFeed, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, Signature, SlotOutcome, StressReport, StressScenario, StressSource, StressSourceKind, StressTestArgs, TOKEN_COMPRESSOR, TimeLockContract, TimelockTransaction, TimelockTxParams, TimelockTxs, TokenCompressorContract, TreasurySplitterContract, TreeNode, UNBOUNDED_DOWN, UNBOUNDED_UP, UnpauseCreditManagerParams, ValueParams, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, classifySources, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getFeedDecimals, getLatestPrices, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, groupOverride, handleSalt, normalizeSignature, perturb, priceFeedSalt, priceFeedSetupParams, rateStub, readForest, readRateTargets, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreMarket, shortenHash, significantTrunc, slotHarm, sourcesByFeed, verdictOf };

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

@@ -8,8 +8,8 @@ import { convertQueueBatchToExecuteTx } from "./governance/timelock-txs.js";
 import "./governance/index.js";
 import { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, TOKEN_COMPRESSOR } from "./literals.js";
 import { getPriceUpdateTx } from "./price-update/get-price-update-tx.js";
-import { getPrices } from "./price-update/get-prices.js";
+import { getFeedDecimals, getLatestPrices, getPrices } from "./price-update/get-prices.js";
 import { GetUpdatablePriceFeedsArgs, getUpdatablePriceFeeds } from "./price-update/get-updatable-feeds.js";
 import "./price-update/index.js";
 import { normalizeSignature } from "./signature.js";
-export { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, FunctionParams, GetUpdatablePriceFeedsArgs, INSTANCE_MANAGER, InstanceTxs, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, TOKEN_COMPRESSOR, TimelockTxs, ValueParams, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, shortenHash, significantTrunc };
+export { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, FunctionParams, GetUpdatablePriceFeedsArgs, INSTANCE_MANAGER, InstanceTxs, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, TOKEN_COMPRESSOR, TimelockTxs, ValueParams, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getFeedDecimals, getLatestPrices, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, shortenHash, significantTrunc };

package/dist/types/permissionless/utils/price-update/get-prices.d.ts

@@ -1,5 +1,38 @@
 import { Address, PublicClient } from "viem";
 //#region src/permissionless/utils/price-update/get-prices.d.ts
+/**
+ * The scale each feed's answer is in, in one multicall.
+ *
+ * Part of the Chainlink interface every feed in a Gearbox tree implements,
+ * and the only way to read an answer that is not an oracle's own: a feed an
+ * oracle holds reports 8 decimals by construction, while the feeds beneath a
+ * composite are whatever was deployed — an ETH/USD aggregator at 8 and a
+ * rate leg at 18 sit under the same parent.
+ *
+ * `null` is a feed that would not answer, which a caller should treat as
+ * unknown rather than defaulting it to 8.
+ */
+export declare function getFeedDecimals({ client, priceFeeds }: {
+  client: PublicClient;
+  priceFeeds: Address[];
+}): Promise<Record<Address, number | null>>;
+/**
+ * What the feeds report as they stand, in one multicall.
+ *
+ * What {@link getPrices} does without the part that makes it expensive: no
+ * `OnchainSDK` to attach and no update transactions to assemble, which is the
+ * whole cost of that call and is wasted on a feed that answers already. A feed
+ * that needs a fresh answer before it will be read comes back `null` here, so
+ * a caller that must price those falls back to {@link getPrices} for them and
+ * pays once for the few rather than once for all.
+ *
+ * `null` is also a feed whose read reverted for any other reason, which is not
+ * a zero.
+ */
+export declare function getLatestPrices({ client, priceFeeds }: {
+  client: PublicClient;
+  priceFeeds: Address[];
+}): Promise<Record<Address, bigint | null>>;
 export declare function getPrices({ client, priceFeeds, chunkSize, gasLimit }: {
   client: PublicClient;
   priceFeeds: Address[];

package/dist/types/permissionless/utils/price-update/index.d.ts

@@ -1,4 +1,4 @@
 import { getPriceUpdateTx } from "./get-price-update-tx.js";
-import { getPrices } from "./get-prices.js";
+import { getFeedDecimals, getLatestPrices, getPrices } from "./get-prices.js";
 import { GetUpdatablePriceFeedsArgs, getUpdatablePriceFeeds } from "./get-updatable-feeds.js";
-export { GetUpdatablePriceFeedsArgs, getPriceUpdateTx, getPrices, getUpdatablePriceFeeds };
+export { GetUpdatablePriceFeedsArgs, getFeedDecimals, getLatestPrices, getPriceUpdateTx, getPrices, getUpdatablePriceFeeds };