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

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

@@ -0,0 +1,57 @@
+import { GroupScenarioOutcome, SlotOutcome } from "./types.js";
+//#region src/permissionless/api/oracles/stress/score.d.ts
+/**
+ * Turning what a group did into a mark out of ten.
+ *
+ * Any single number over a thing this shaped is a judgement, so the one here
+ * is spelled out rather than tuned: what it weighs, and why each term is
+ * weighed that way, is in the comments below, and every figure it is computed
+ * from stays in the report so a reader who disagrees can reweigh them.
+ **/
+/**
+ * How bad one slot's outcome is, on nought to one.
+ *
+ * Two kinds of harm, which are not the same kind of problem:
+ *
+ *  - a wrong price. The collateral is valued against the market's underlying,
+ *    so what matters is the ratio and not either leg: a market whose
+ *    collateral and underlying both doubled has not moved. Overvalued
+ *    collateral is borrowed against and the loan is never repaid; undervalued
+ *    collateral is liquidated out from under an account that was solvent.
+ *    Both are counted, because a reader asking what a source can do to them
+ *    is exposed to each.
+ *
+ *  - a price that stopped. The slot reverted where it used to answer, which
+ *    freezes the market: nothing can be borrowed and, worse, nothing can be
+ *    liquidated. Scored at half a full mispricing — it is a liveness failure
+ *    rather than a licence to drain, and it is also loud, where a wrong number
+ *    is silent.
+ *
+ * A hundredfold move in the ratio is full harm. Ten times is a half, and the
+ * curve is logarithmic between them because the damage is: a position is
+ * liquidatable somewhere around a tenth of a move, and everything past that is
+ * degrees of already-gone.
+ */
+export declare function slotHarm(slot: SlotOutcome): number;
+/**
+ * The group's mark, over every scenario it was put through.
+ *
+ * Two views of the same slots, because either alone misleads. Weighing harm by
+ * the quota riding on it is what a reader with money in the protocol wants —
+ * a source that can only move a market with nothing in it has not done much.
+ * But a market with nothing in it today is where tomorrow's deposit goes, so
+ * the worst slot regardless of size is carried too, at a smaller weight.
+ *
+ * Ten is a group that moved nothing. Nought is one that revalued everything
+ * the chain has out.
+ */
+export declare function scoreGroup(outcomes: GroupScenarioOutcome[]): number;
+/**
+ * The one line the score stands for.
+ *
+ * Says which of the two failures the group causes, because the remedies
+ * differ: a wrong price is answered with bounds and a second feed, a dead one
+ * with a reserve feed and a staleness period.
+ */
+export declare function verdictOf(group: string, score: number, outcomes: GroupScenarioOutcome[], reachableSlots: number, reachableUsd: number, responsive: number, silentSources: number, undefendedPositions: number, selfContained: boolean): string;
+//#endregion

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

@@ -0,0 +1,272 @@
+import { Address } from "viem";
+//#region src/permissionless/api/oracles/stress/types.d.ts
+/**
+ * How a source is made to lie.
+ *
+ * `feed` is a price feed that reads nothing else on chain — a Chainlink
+ * aggregator, a Redstone or Pyth feed, a protocol's own rate adapter — and is
+ * perturbed by overriding what it answers.
+ *
+ * `rate` is the contract a Gearbox LP feed reads an exchange rate from: the
+ * wstETH token, an ERC-4626 vault, a Curve pool. The feed itself is not
+ * overridden, because it also reads the price of what the rate is denominated
+ * in — overriding the whole feed would charge the protocol with a failure of
+ * whatever prices its underlying.
+ **/
+export type StressSourceKind = "feed" | "rate";
+/**
+ * One thing that can lie, and what happens downstream when it does.
+ *
+ * A source is not a feed. Several feeds can read the same aggregator, and
+ * several of an oracle's trees can carry the same node; what the test varies
+ * is the contract, once, and then looks at every feed built over it.
+ **/
+export interface StressSource {
+  chainId: number;
+  /**
+   * The set it fails with.
+   *
+   * Sources sharing a group are taken to fail together, which is the whole
+   * reason for grouping: Chainlink's feeds share an operator and an
+   * infrastructure, so a reader who trusts one trusts all of them. A source
+   * nothing else is correlated with is a group of one, which is the honest
+   * answer rather than a bucket named "other".
+   */
+  group: string;
+  kind: StressSourceKind;
+  /** The contract overridden. */
+  target: Address;
+  /**
+   * The feed the source governs, which for a `feed` source is the target
+   * itself and for a `rate` source is the LP feed reading it.
+   */
+  feed: Address;
+  /** Gearbox contract type of that feed, or `""` for one it never deployed. */
+  contractType: string;
+  /** What the feed says it is, which is how most sources are identified. */
+  description: string;
+  /**
+   * Whether the group was recognised or only inferred from the feed itself.
+   *
+   * `false` is not a failure — the source is still perturbed and still
+   * scored — but it is a group of one named after a description, so a reader
+   * cannot tell whether it shares a fate with anything else. The share of
+   * value behind unidentified sources is this analysis's blind spot and is
+   * reported as such.
+   */
+  identified: boolean;
+  /** Which rule named the group, so a reader can audit the partition. */
+  via: string;
+  /**
+   * Whether anything feeds this source at all.
+   *
+   * `false` for a feed that carries its answer in its own code — a constant,
+   * a zero — which cannot report a wrong price because nobody reports one to
+   * it. Such a feed is still a risk, but the risk is whoever can replace the
+   * contract, not whoever publishes to it, and overriding it would be
+   * measuring the wrong thing. Reported and not simulated.
+   */
+  perturbable: boolean;
+  /**
+   * What the source reports now, or `null` for one that is not answering.
+   *
+   * A source with no baseline is left out of every override: a contract that
+   * says nothing cannot be made to say something else, and inventing a figure
+   * for it would be testing a feed that does not exist. A group whose sources
+   * are all like this scores well because it can do nothing — which is worth
+   * knowing, but is not the same as being safe, and is why this is reported.
+   */
+  baseline: bigint | null;
+}
+/** One perturbation, as a multiple of what the source reports now. */
+export interface StressScenario {
+  label: string;
+  /**
+   * What the source's answer is multiplied by.
+   *
+   * `Infinity` and `0` stand for the two unbounded ends and are realised as
+   * the largest and smallest values the feed's own type can carry, which is as
+   * infinite as a `int256` gets.
+   */
+  multiplier: number;
+}
+/**
+ * What one feed answered under one scenario.
+ *
+ * `null` is a read that reverted, which is a different outcome from a wrong
+ * number and is scored differently: a market whose oracle reverts cannot be
+ * borrowed from or liquidated, where one that answers a wrong number can be
+ * drained.
+ **/
+export interface FeedOutcome {
+  feed: Address;
+  /** What it answers now, with nothing overridden. */
+  base: bigint | null;
+  /** What it answers under the scenario. */
+  stressed: bigint | null;
+  /**
+   * `stressed / base`, or `null` where either end could not be read.
+   *
+   * The headline number: 1 is a feed the group cannot move, and anything far
+   * from it is a feed it can.
+   */
+  factor: number | null;
+}
+/**
+ * What one market's slot looked like under one scenario.
+ *
+ * A slot and not a market: a token's main and reserve feeds are two slots, and
+ * their disagreement is one of the things worth seeing.
+ **/
+export interface SlotOutcome {
+  market: Address;
+  marketName: string | null;
+  curatorName: string | null;
+  token: Address;
+  tokenSymbol: string | null;
+  reserve: boolean;
+  isUnderlying: boolean;
+  feed: FeedOutcome;
+  /**
+   * How the collateral's price moved against the market's own underlying.
+   *
+   * What a position is actually valued by: a market whose underlying and
+   * collateral both doubled has not moved at all, and one where only the
+   * collateral did has doubled every account's health. `null` where either
+   * side could not be priced.
+   */
+  ratioFactor: number | null;
+  /** What the market has quoted against the token, in USD at current prices. */
+  quotaUsedUsd: number | null;
+}
+/**
+ * What one group of sources does to one chain, under one scenario.
+ **/
+export interface GroupScenarioOutcome {
+  scenario: StressScenario;
+  slots: SlotOutcome[];
+  /** Largest `ratioFactor` over the slots, and the smallest. */
+  worstInflation: number | null;
+  worstDeflation: number | null;
+  /** Slots whose feed stopped answering, which it did answer before. */
+  brokenSlots: number;
+  /**
+   * Slots whose feed does not answer even with nothing overridden.
+   *
+   * Not this group's doing and not a result of the sweep, but reported with
+   * it: a slot priced through a feed that is reverting right now cannot be
+   * made worse by anything, and a group that reaches only such slots would
+   * otherwise score as harmless when what it really is, is moot.
+   */
+  deadSlots: number;
+  /**
+   * Quota in USD riding on the slots this scenario moved at all, over the
+   * quota riding on every slot — how much of the chain the group reaches.
+   */
+  valueAtRisk: number;
+}
+/**
+ * Where a group starts to matter, found by bisection on the multiplier.
+ *
+ * `null` means no multiplier in the searched range moved the market past the
+ * threshold, which for a group that reaches nothing is the expected answer.
+ **/
+export interface BreakingPoint {
+  market: Address;
+  token: Address;
+  /** Smallest upward multiple of the source that moves the ratio past 2×. */
+  inflation: number | null;
+  /** Largest downward multiple that moves it past ½×. */
+  deflation: number | null;
+}
+/** What one group of sources can do to one chain. */
+export interface GroupReport {
+  chainId: number;
+  group: string;
+  sources: StressSource[];
+  /** Whether every source in it was recognised rather than inferred. */
+  identified: boolean;
+  /** Market slots that read a feed built over any of its sources. */
+  reachableSlots: number;
+  /** Quota in USD riding on those slots, counted once per `(market, token)`. */
+  reachableUsd: number;
+  /**
+   * Positions whose main feed and reserve feed both read something of this
+   * group.
+   *
+   * A reserve feed exists so that a market has something to fall back on. One
+   * that reads the same source as the feed it is backing up falls back onto
+   * the same failure, and nothing about the pair says so — both are perfectly
+   * healthy feeds from two different vendors with one number underneath.
+   */
+  undefendedPositions: number;
+  outcomes: GroupScenarioOutcome[];
+  breakingPoints: BreakingPoint[];
+  /**
+   * How many of its reachable slots answered differently under a perturbation
+   * far too small for any bound to object to, over how many were reachable.
+   *
+   * The control. A group that moves nothing under the unbounded ends has
+   * either been stopped by something — a bound, a sanity check, a second feed
+   * — or was never really perturbed at all, and from the big scenarios alone
+   * those two look identical. A slot that responds to a tenth of a percent is
+   * a slot this test is genuinely driving; one that does not is a slot whose
+   * every other result should be read as "unknown" rather than as "safe".
+   */
+  responsive: number;
+  /**
+   * Sources of the group that are not answering as it stands, so nothing
+   * could be perturbed about them.
+   */
+  silentSources: number;
+  /**
+   * 0 to 10, where 10 is a group that can do nothing and 0 one that can
+   * revalue the whole chain. See `score.ts` for what goes into it.
+   */
+  score: number;
+  /** One line a reader can act on. */
+  verdict: string;
+}
+/** Everything one run looked at. */
+export interface StressReport {
+  chainId: number;
+  /** Slots read, before any grouping. */
+  slots: number;
+  /** Distinct feeds the markets read. */
+  roots: number;
+  /** Distinct nodes in all the oracles' trees. */
+  nodes: number;
+  /**
+   * Slots whose feed does not answer at the current block, before anything is
+   * perturbed — a standing fault rather than a finding of this test, and the
+   * first thing to look at in its output.
+   */
+  deadSlots: number;
+  sources: StressSource[];
+  /**
+   * Quota in USD this chain's markets have out, and the share of it priced
+   * through at least one unidentified source.
+   *
+   * The second figure is the blind spot: value whose source could be named
+   * only by its own description, so nothing says what else fails with it.
+   */
+  totalUsd: number;
+  unidentifiedUsd: number;
+  groups: GroupReport[];
+}
+/** Args of {@link PermissionlessOracles.stressTest}. */
+export interface StressTestArgs {
+  chainId: number;
+  /**
+   * Which perturbations to apply. Defaults to the two unbounded ends.
+   */
+  scenarios?: StressScenario[];
+  /**
+   * Also bisect for each market's breaking point, which costs a few more
+   * calls per group. On by default.
+   */
+  thresholds?: boolean;
+  /** Only these groups, for a second look at one of them. */
+  groups?: string[];
+}
+//#endregion

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

@@ -129,6 +129,44 @@ export interface PermissionlessPriceFeedMarket extends PermissionlessIndexedPric
    */
   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.
  *
@@ -373,6 +411,26 @@ export interface PriceFeedRef {
 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.
  *

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 { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedPrice, PriceFeedRef } from "./api/oracles/types.js";
+import { AssetScore, AssetScoresArgs, GroupImpact, 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 { REVERT_SCORE, SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } 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, readUnder, 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 { getLatestPrices, 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, AssetArgs, AssetCap, AssetsArgs, 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, FeedCap, ForbidAdapterParams, ForbidFeedsArgs, ForbidTokenParams, FunctionParams, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, 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, MarketCap, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PauseCreditManagerParams, PeripheryDomain, PermissionlessAnalytics, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PreparedDeployment, PreparedPriceFeedDeployment, PriceChartArgs, PriceFeed, PriceFeedArgs, PriceFeedChartPoint, PriceFeedConstructorParam, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedParamType, PriceFeedParams, PriceFeedPrice, PriceFeedPriceChart, PriceFeedRef, 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, getLatestPrices, 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, 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, GroupImpact, GroupReport, GroupScenarioOutcome, 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, REVERT_SCORE, RecoveryMessage, RoutingManagerContract, SCORE_MULTIPLIER, SafeBatch, SafeMeta, SafeTx, 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, factorOf, finalPrice, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getFeedDecimals, getLatestPrices, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, groupOverride, handleSalt, normalizeSignature, perturb, priceFeedSalt, priceFeedSetupParams, rateStub, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runStressTest, scoreGroup, scoreOfFactor, shortenHash, significantTrunc, slotHarm, sourcesByFeed, verdictOf, worstOf };

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 { getLatestPrices, 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, getLatestPrices, 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,21 @@
 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.
  *

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "18.2.0-next.10",
+  "version": "18.2.0-next.12",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {