@1delta/margin-fetcher 0.0.339 → 0.0.341

package/dist/prices/oracle-prices/derivation.d.ts

@@ -0,0 +1,25 @@
+import { OraclePriceEntry, PriceDerivation } from './types';
+/**
+ * Rank order of `PriceDerivation` — lower is better. Used directly as a
+ * ranking tier in `selectAssetGroupPrices`.
+ */
+export declare const DERIVATION_RANK: Record<PriceDerivation, number>;
+/**
+ * Resolve an entry's derivation class.
+ *
+ * Precedence:
+ * 1. What the fetcher put on the entry (most specific — e.g. Euler knows
+ *    per-vault whether its unit of account is a fiat code or a token).
+ * 2. The fetcher group's declared default. `derived` wins over the
+ *    structural guess below: Fluid/Silo collateral legs carry a `baseAsset`
+ *    exactly like a real quoted feed, but there is no feed for the asset —
+ *    only a market ratio.
+ * 3. The `baseAsset`/`staticBase` convention every fetcher already follows:
+ *    a non-base asset carrying a `baseAsset` is quoted in it; anything else
+ *    is a direct USD read.
+ *
+ * Step 3 is what keeps third-party or older entries (which predate the
+ * `derivation` field) from silently ranking as `direct`.
+ */
+export declare function resolveDerivation(entry: OraclePriceEntry, groupDefault?: PriceDerivation): PriceDerivation;
+//# sourceMappingURL=derivation.d.ts.map

package/dist/prices/oracle-prices/derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/derivation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE3D;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAI3D,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,gBAAgB,EACvB,YAAY,CAAC,EAAE,eAAe,GAC7B,eAAe,CAKjB"}

package/dist/prices/oracle-prices/feedStaleness.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Feed timestamps for AAVE-family oracles.
+ *
+ * `AaveOracle.getAssetPrice()` returns a bare uint — no timestamp — so the
+ * only way to tell a live feed from a dead one is to resolve the per-asset
+ * source (`getSourceOfAsset`) and read `latestRoundData().updatedAt` on it.
+ * That matters because AAVE forks are the dominant (often only) price source
+ * on several chains: Avalanche has no Compound V3 deployment at all, so
+ * before this probe existed NOTHING on that chain was ever checked for
+ * staleness.
+ *
+ * Two multicalls, both `allowFailure` and both best-effort: a chain where the
+ * probe fails just yields no timestamps, never a missing price. Roughly half
+ * of AAVE's sources are price-cap adapters that do not implement
+ * `latestRoundData` — those legitimately return no timestamp.
+ */
+/** asset (lowercase) -> feed timestamp info */
+export type AssetFeedInfo = {
+    source: string;
+    updatedAt: number;
+    description?: string;
+};
+/** lender -> asset (lowercase) -> feed info */
+export type FeedTimestampMap = {
+    [lender: string]: {
+        [asset: string]: AssetFeedInfo;
+    };
+};
+interface ProbeOptions {
+    rpcOverrides?: {
+        [chainId: string]: string[];
+    };
+    batchSize?: number;
+    retries?: number;
+}
+/**
+ * Resolve `updatedAt` for every AAVE-family (lender, asset) pair on a chain.
+ *
+ * Returns an empty map — never throws — when the chain has no AAVE-family
+ * lender or when the RPC calls fail.
+ */
+export declare function probeAaveFeedTimestamps(chainId: string, options?: ProbeOptions): Promise<FeedTimestampMap>;
+export {};
+//# sourceMappingURL=feedStaleness.d.ts.map

package/dist/prices/oracle-prices/feedStaleness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedStaleness.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/feedStaleness.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AAEH,+CAA+C;AAC/C,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,+CAA+C;AAC/C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAAA;KAAE,CAAA;CACrD,CAAA;AAcD,UAAU,YAAY;IACpB,YAAY,CAAC,EAAE;QAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAA;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAQD;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,gBAAgB,CAAC,CAgG3B"}

package/dist/prices/oracle-prices/feedStats.d.ts

@@ -0,0 +1,145 @@
+import { OraclePriceEntry, OutlierGuardConfig, StructuredOraclePrices, TokenListMap } from './types';
+/**
+ * Self-calibrating per-feed quality stats.
+ *
+ * Everything here is learned from data the price pipeline already fetches —
+ * nobody ranks a lender by hand. Two observations per cycle per feed:
+ *
+ * 1. **Its own update cadence.** Chainlink heartbeats range from ~27s to 24h,
+ *    and we cannot read a feed's configured heartbeat on-chain. Recording the
+ *    gaps between distinct `updatedAt` values learns it, so "stale" becomes
+ *    "far past what THIS feed normally does" instead of one global constant
+ *    that is wrong for almost every feed.
+ *
+ * 2. **Its agreement with the rest of the market.** A feed that keeps
+ *    disagreeing with every other source for the same asset is broken,
+ *    whether or not it still updates. This is the only signal that catches a
+ *    frozen Compound-V2-style oracle, which exposes no timestamp at all.
+ *
+ * The stats are a plain JSON blob: this module computes, the caller persists
+ * (worker KV, a DB row, a file — margin-fetcher stays storage-agnostic).
+ *
+ * SAFETY: reliability may only ever DEMOTE a candidate. A cold start, a lost
+ * blob or a corrupted stat therefore degrades to the structural ranking
+ * rather than promoting a bad price.
+ */
+/** Stats for one feed, keyed `<chainId>|<feedKey>`. */
+export interface FeedStat {
+    /** Chain the feed lives on */
+    chainId: string;
+    /**
+     * Feed identity: the aggregator address when the oracle exposes one,
+     * otherwise `lender|asset` (Compound V2 forks, Morpho `price()` — no
+     * readable feed address, but still a stable identity to score).
+     */
+    feedKey: string;
+    /** Most recent `updatedAt` seen (unix seconds); 0 when the feed has none */
+    lastUpdatedAt: number;
+    /** Wall-clock (unix seconds) of the last observation */
+    lastObservedAt: number;
+    /** Number of distinct updates observed */
+    updates: number;
+    /** Rolling estimate of this feed's typical update interval, seconds */
+    intervalEwmaSeconds: number;
+    /** Largest interval observed between updates, seconds */
+    intervalMaxSeconds: number;
+    /** Rolling |price/consensus - 1| across cycles; undefined until measurable */
+    deviationEwma?: number;
+    /** Number of cycles where a consensus existed to compare against */
+    deviationSamples: number;
+}
+export type FeedStatsMap = {
+    [key: string]: FeedStat;
+};
+/**
+ * Cycles of agreement data required before `classifyReliability` will act.
+ * Below this, a feed is treated as unknown (neutral), never as bad.
+ */
+export declare const MIN_DEVIATION_SAMPLES = 5;
+/** Rolling deviation above which a feed is considered broken (25%). */
+export declare const BAD_DEVIATION = 0.25;
+/** Rolling deviation above which a feed is considered degraded (5%). */
+export declare const DEGRADED_DEVIATION = 0.05;
+/**
+ * Multiple of a feed's own learned interval past which it counts as stale.
+ * Generous because the EWMA tracks the mean while heartbeats are an upper
+ * bound — a 24h-heartbeat feed that usually updates on 6h price moves must
+ * not be called stale at 12h.
+ */
+export declare const STALE_INTERVAL_MULTIPLE = 4;
+/**
+ * Minimum learned interval used for the staleness test, seconds. Stops a
+ * fast feed (27s heartbeat) from being called stale after two minutes of
+ * quiet, which is normal when the price does not move.
+ */
+export declare const MIN_LEARNED_STALE_SECONDS: number;
+/** Updates required before a learned interval is trusted over the default. */
+export declare const MIN_UPDATES_FOR_INTERVAL = 4;
+export type FreshnessClass = 'fresh' | 'stale' | 'unknown';
+export type ReliabilityClass = 'good' | 'degraded' | 'bad' | 'unknown';
+/** Rank order — lower is better; used directly as a ranking tier. */
+export declare const FRESHNESS_RANK: Record<FreshnessClass, number>;
+export declare const RELIABILITY_RANK: Record<ReliabilityClass, number>;
+/**
+ * Stable identity of the source behind an entry.
+ *
+ * Prefers the aggregator address so the many protocols reading the same
+ * Chainlink feed collapse to one source — on Avalanche, Aave V3, Aave V2,
+ * Granary, Nereus and Benqi all read the same AVAX/USD aggregator, and
+ * counting them as five independent opinions is exactly the mistake that
+ * makes consensus checks worthless.
+ *
+ * When no aggregator is readable (Compound V2 forks, Morpho `price()`), the
+ * fallback is keyed on the protocol FAMILY, not the raw lender key: Morpho's
+ * per-market keys are one protocol's opinion repeated, not N sources.
+ */
+export declare function feedKeyOf(entry: OraclePriceEntry, lender: string): string;
+export declare function feedStatKey(chainId: string, feedKey: string): string;
+/**
+ * One observation of a feed within a cycle.
+ * `consensusDeviation` is `|price/consensus - 1|`, omitted when the asset
+ * group had no independent consensus to compare against.
+ */
+export interface FeedObservation {
+    chainId: string;
+    feedKey: string;
+    updatedAt?: number;
+    consensusDeviation?: number;
+}
+/**
+ * Fold a cycle's observations into the stats blob. Pure and idempotent for
+ * repeated `updatedAt` values, so re-running a cycle cannot corrupt the
+ * learned cadence.
+ */
+export declare function updateFeedStats(prev: FeedStatsMap, observations: FeedObservation[], nowSeconds?: number): FeedStatsMap;
+/**
+ * Is this feed past its own normal cadence?
+ *
+ * Falls back to `defaultStaleSeconds` until the feed has enough observed
+ * updates to trust its learned interval.
+ */
+export declare function classifyFreshness(updatedAt: number | undefined, stat: FeedStat | undefined, defaultStaleSeconds: number, nowSeconds?: number): FreshnessClass;
+/** How far this feed habitually sits from the rest of the market. */
+export declare function classifyReliability(stat: FeedStat | undefined): ReliabilityClass;
+/**
+ * Collect this cycle's observations straight from the structured prices.
+ *
+ * A feed is only scored on agreement when the rest of the group forms a
+ * STRONG consensus — the same standard the selection guard applies. Learning
+ * "this feed disagrees" from two other sources would repeat the mistake the
+ * guard exists to avoid: for a thinly-sourced yield-bearing token, the
+ * majority is often the one that is wrong, and a feed must never accumulate
+ * a bad reputation for being right about something obscure.
+ *
+ * The reference excludes the feed being scored, so no feed is ever measured
+ * against itself, and a protocol emitting one entry per market votes once.
+ */
+export declare function collectFeedObservations(structuredPrices: StructuredOraclePrices, lists?: {
+    [chainId: string]: TokenListMap;
+}, guard?: OutlierGuardConfig): FeedObservation[];
+/**
+ * Drop stats for feeds not seen in a long time so the blob cannot grow
+ * without bound as markets come and go.
+ */
+export declare function pruneFeedStats(stats: FeedStatsMap, maxAgeSeconds?: number, nowSeconds?: number): FeedStatsMap;
+//# sourceMappingURL=feedStats.d.ts.map

package/dist/prices/oracle-prices/feedStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedStats.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/feedStats.ts"],"names":[],"mappings":"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"}

package/dist/prices/oracle-prices/fetchOraclePrices.d.ts

@@ -34,9 +34,21 @@ export interface FetchOraclePricesOptions {
     /**
      * Chainlink staleness threshold in seconds (default: 3600 = 1 hour).
      * Feeds with updatedAt older than this are flagged in diagnostics.
-     * Set to 0 to disable staleness checking.
+     * Set to 0 to disable staleness checking (also skips the AAVE feed probe).
+     *
+     * This is a REPORTING threshold only — it is intentionally tighter than the
+     * `staleRejectSeconds` used by `selectAssetGroupPrices` to demote a price,
+     * because a healthy 24h-heartbeat stablecoin feed is routinely hours old.
      */
     stalenessThresholdSeconds?: number;
+    /**
+     * Resolve AAVE-family feed sources and read their `updatedAt` (default true
+     * when staleness checking is on). Costs two extra multicalls per chain, run
+     * concurrently with the price groups. Without it, chains whose only price
+     * source is an AAVE fork — Avalanche has no Compound V3 deployment — get no
+     * staleness coverage at all.
+     */
+    probeFeedStaleness?: boolean;
     /**
      * Only run these fetcher groups. Useful for debugging individual protocols.
      * Values: 'aave', 'compoundV2', 'compoundV3', 'lista', 'eulerV2', 'aaveV4',
@@ -61,5 +73,5 @@ export declare function fetchOraclePrices(chainIds: string[], rpcOverrides?: {
     [chainId: string]: string[];
 }, lists?: TokenListInput, retries?: number, batchSize?: {
     [chainId: string]: number;
-} | undefined, allowFailure?: boolean, basePrices?: USDPriceMap, morphoMarketOverrides?: MorphoMarketOverrides, listaMarketOverrides?: ListaMarketOverrides, stalenessThresholdSeconds?: number, onlyFetchers?: string[]): Promise<OraclePricesResult>;
+} | undefined, allowFailure?: boolean, basePrices?: USDPriceMap, morphoMarketOverrides?: MorphoMarketOverrides, listaMarketOverrides?: ListaMarketOverrides, stalenessThresholdSeconds?: number, onlyFetchers?: string[], probeFeedStaleness?: boolean): Promise<OraclePricesResult>;
 //# sourceMappingURL=fetchOraclePrices.d.ts.map

package/dist/prices/oracle-prices/fetchOraclePrices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchOraclePrices.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/fetchOraclePrices.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,WAAW,EAEX,YAAY,EAKZ,kBAAkB,EAEnB,MAAM,SAAS,CAAA;AAChB,OAAO,EA2BL,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAA;AAiBnB;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAAA;CAChC,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,2CAA2C;IAC3C,YAAY,CAAC,EAAE;QAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAA;IAC9C,sEAAsE;IACtE,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,mDAAmD;IACnD,SAAS,CAAC,EAAE;QAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;IACzC,gEAAgE;IAChE,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,gEAAgE;IAChE,UAAU,CAAC,EAAE,WAAW,CAAA;IACxB,oDAAoD;IACpD,qBAAqB,CAAC,EAAE,qBAAqB,CAAA;IAC7C,mDAAmD;IACnD,oBAAoB,CAAC,EAAE,oBAAoB,CAAA;IAC3C;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAClC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB;AA2KD;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,CAAC,EAAE;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,EAC9C,KAAK,GAAE,cAAmB,EAC1B,OAAO,SAAI,EACX,SAAS,GAAE;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,SAAqB,EAChE,YAAY,UAAO,EACnB,UAAU,GAAE,WAAgB,EAC5B,qBAAqB,CAAC,EAAE,qBAAqB,EAC7C,oBAAoB,CAAC,EAAE,oBAAoB,EAC3C,yBAAyB,SAAO,EAChC,YAAY,CAAC,EAAE,MAAM,EAAE,GACtB,OAAO,CAAC,kBAAkB,CAAC,CAm7B7B"}
+{"version":3,"file":"fetchOraclePrices.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/fetchOraclePrices.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,WAAW,EAEX,YAAY,EAKZ,kBAAkB,EAEnB,MAAM,SAAS,CAAA;AAChB,OAAO,EA2BL,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAA;AAoBnB;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAAA;CAChC,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,2CAA2C;IAC3C,YAAY,CAAC,EAAE;QAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAA;IAC9C,sEAAsE;IACtE,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,mDAAmD;IACnD,SAAS,CAAC,EAAE;QAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;IACzC,gEAAgE;IAChE,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,gEAAgE;IAChE,UAAU,CAAC,EAAE,WAAW,CAAA;IACxB,oDAAoD;IACpD,qBAAqB,CAAC,EAAE,qBAAqB,CAAA;IAC7C,mDAAmD;IACnD,oBAAoB,CAAC,EAAE,oBAAoB,CAAA;IAC3C;;;;;;;;OAQG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAClC;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB;AAoLD;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,CAAC,EAAE;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,EAC9C,KAAK,GAAE,cAAmB,EAC1B,OAAO,SAAI,EACX,SAAS,GAAE;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,SAAqB,EAChE,YAAY,UAAO,EACnB,UAAU,GAAE,WAAgB,EAC5B,qBAAqB,CAAC,EAAE,qBAAqB,EAC7C,oBAAoB,CAAC,EAAE,oBAAoB,EAC3C,yBAAyB,SAAO,EAChC,YAAY,CAAC,EAAE,MAAM,EAAE,EACvB,kBAAkB,UAAO,GACxB,OAAO,CAAC,kBAAkB,CAAC,CAg/B7B"}

package/dist/prices/oracle-prices/fetchers/aave.d.ts

@@ -79,6 +79,20 @@ export declare function getAaveAbi(): readonly [{
     }];
     readonly stateMutability: "view";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly name: "getSourceOfAsset";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
 }];
 /**
  * AAVE Oracle Fetcher module

package/dist/prices/oracle-prices/fetchers/aave.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aave.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/aave.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAIjB;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,aAAa;IAC1D,0DAA0D;IAC1D,qBAAqB,EAAE,MAAM,CAAA;IAC7B,kCAAkC;IAClC,cAAc,EAAE,MAAM,CAAA;IACtB,wDAAwD;IACxD,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,2DAA2D;IAC3D,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAmBD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,qBAAqB,CAAC,EAAE,CAqDxC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CAqEpB;AAED;;GAEG;AACH,wBAAgB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEzB;AAED;;GAEG;AACH,eAAO,MAAM,WAAW;;;;CAIvB,CAAA"}
+{"version":3,"file":"aave.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/aave.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAIjB;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,aAAa;IAC1D,0DAA0D;IAC1D,qBAAqB,EAAE,MAAM,CAAA;IAC7B,kCAAkC;IAClC,cAAc,EAAE,MAAM,CAAA;IACtB,wDAAwD;IACxD,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,2DAA2D;IAC3D,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAmBD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,qBAAqB,CAAC,EAAE,CAqDxC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CAqEpB;AAED;;GAEG;AACH,wBAAgB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEzB;AAED;;GAEG;AACH,eAAO,MAAM,WAAW;;;;CAIvB,CAAA"}

package/dist/prices/oracle-prices/fetchers/compoundV3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compoundV3.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/compoundV3.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EACnB,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAKjB;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;EAczB,CAAA;AAkBV;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,mBAAmB,EAAE,CAAC,EAAE,CA0DxC;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,mBAAmB,EAAE,EAC3B,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CAqDpB;AAED;;GAEG;AACH,wBAAgB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;GAE/B;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;CAI7B,CAAA"}
+{"version":3,"file":"compoundV3.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/compoundV3.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EACnB,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAKjB;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;EAczB,CAAA;AAqBV;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,mBAAmB,EAAE,CAAC,EAAE,CAwDxC;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,mBAAmB,EAAE,EAC3B,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CA6DpB;AAED;;GAEG;AACH,wBAAgB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;GAE/B;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;CAI7B,CAAA"}

package/dist/prices/oracle-prices/fetchers/euler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"euler.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/euler.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AA6CjB;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,OAAO,CAAA;CACtB;AAKD;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,gBAAgB,EAAE,CAAC,EAAE,CA6CrC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,gBAAgB,EAAE,EACxB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CAmEpB;AAED;;GAEG;AACH,wBAAgB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAE5B;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;CAI1B,CAAA"}
+{"version":3,"file":"euler.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/euler.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AA6CjB;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,OAAO,CAAA;CACtB;AAKD;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,gBAAgB,EAAE,CAAC,EAAE,CA6CrC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,gBAAgB,EAAE,EACxB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CA0EpB;AAED;;GAEG;AACH,wBAAgB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAE5B;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;CAI1B,CAAA"}

package/dist/prices/oracle-prices/fetchers/morpho.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"morpho.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/morpho.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAIjB;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAY3D;AAoBD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,CAAC,OAAO,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAAA;CAC1C,CAAA;AAyBD;;;GAGG;AACH,UAAU,iBAAiB;IACzB,OAAO,EAAE,eAAe,EAAE,CAAA;CAC3B;AAgCD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,eAAe,CAAC,EAAE,qBAAqB,CAAA;CACxC;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,oBAAoB,GAC7B,aAAa,CAAC,iBAAiB,CAAC,EAAE,CA6BpC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CAgEpB;AAED;;GAEG;AACH,wBAAgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;GAE3B;AAmCD,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAA;IACzE,eAAe,EAAE;QACf,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,MAAM,CAAA;QAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;KACxB,GAAG,IAAI,CAAA;IACR,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAA;CACvC;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,gBAAgB,EAAE,GAAG,IAAI,CAAC,CAsDpC;AAID;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,eAAe,EAAE,EAC7B,MAAM,EAAE,MAAM,GACb,gBAAgB,EAAE,GAAG,IAAI,CA4F3B;AAED;;GAEG;AACH,eAAO,MAAM,aAAa;;;;CAIzB,CAAA"}
+{"version":3,"file":"morpho.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/morpho.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAIjB;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAY3D;AAoBD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,CAAC,OAAO,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAAA;CAC1C,CAAA;AAyBD;;;GAGG;AACH,UAAU,iBAAiB;IACzB,OAAO,EAAE,eAAe,EAAE,CAAA;CAC3B;AAgCD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,eAAe,CAAC,EAAE,qBAAqB,CAAA;CACxC;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,oBAAoB,GAC7B,aAAa,CAAC,iBAAiB,CAAC,EAAE,CA6BpC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CAgEpB;AAED;;GAEG;AACH,wBAAgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;GAE3B;AAmCD,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAA;IACzE,eAAe,EAAE;QACf,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,MAAM,CAAA;QAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;KACxB,GAAG,IAAI,CAAA;IACR,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAA;CACvC;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,gBAAgB,EAAE,GAAG,IAAI,CAAC,CAsDpC;AAID;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,eAAe,EAAE,EAC7B,MAAM,EAAE,MAAM,GACb,gBAAgB,EAAE,GAAG,IAAI,CAqG3B;AAED;;GAEG;AACH,eAAO,MAAM,aAAa;;;;CAIzB,CAAA"}

package/dist/prices/oracle-prices/index.d.ts

@@ -1,6 +1,11 @@
 export { fetchOraclePrices, type TokenListInput, type FetchOraclePricesOptions, } from './fetchOraclePrices';
-export { selectAssetGroupPrices } from './selectAssetGroupPrices';
-export type { OraclePriceEntry, StructuredOraclePrices, USDPriceMap, TvlMap, FlattenPriorityConfig, ParseContext, TokenListEntry, TokenListMap, MulticallCall, FetcherResult, ParserFn, OracleFetcher, AaveQueryMeta, MorphoQueryMeta, MorphoMarketOverride, ListaQueryMeta, ListaMarketOverride, CompoundV2QueryMeta, CompoundV3QueryMeta, OracleDiagnostics, OraclePricesResult, ChainDiagnostic, TrackerDiagnostic, StaleFeedEntry, } from './types';
+export { selectAssetGroupPrices, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_OUTLIER_GUARD, type SelectPricesOptions, } from './selectAssetGroupPrices';
+export { resolveDerivation, DERIVATION_RANK } from './derivation';
+export { lenderFamily } from './lenderKeys';
+export { consensusReference, rejectOutliers as rejectPriceOutliers, type FeedPriced, } from './outlierGuard';
+export { updateFeedStats, collectFeedObservations, classifyFreshness, classifyReliability, pruneFeedStats, feedKeyOf, feedStatKey, type FeedStat, type FeedStatsMap, type FeedObservation, type FreshnessClass, type ReliabilityClass, } from './feedStats';
+export { probeAaveFeedTimestamps, type FeedTimestampMap, type AssetFeedInfo, } from './feedStaleness';
+export type { OraclePriceEntry, StructuredOraclePrices, USDPriceMap, TvlMap, DepthMap, PriceDerivation, PriceSelection, FlattenPriorityConfig, OutlierGuardConfig, ParseContext, TokenListEntry, TokenListMap, MulticallCall, FetcherResult, ParserFn, OracleFetcher, AaveQueryMeta, MorphoQueryMeta, MorphoMarketOverride, ListaQueryMeta, ListaMarketOverride, CompoundV2QueryMeta, CompoundV3QueryMeta, OracleDiagnostics, OraclePricesResult, ChainDiagnostic, TrackerDiagnostic, StaleFeedEntry, } from './types';
 export { aaveFetcher, getAaveCalls, parseAaveResults, getAaveAbi, } from './fetchers/aave';
 export { morphoFetcher, getMorphoCalls, parseMorphoResults, getMorphoAbi, fetchMorphoGraphQLPrices, type MorphoMarketOverrides, type MorphoFetcherContext, } from './fetchers/morpho';
 export { midnightFetcher, getMidnightCalls, parseMidnightResults, getMidnightAbi, } from './fetchers/midnight';

package/dist/prices/oracle-prices/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,wBAAwB,GAC9B,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAA;AAGjE,YAAY,EACV,gBAAgB,EAChB,sBAAsB,EACtB,WAAW,EACX,MAAM,EACN,qBAAqB,EACrB,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,aAAa,EACb,aAAa,EACb,QAAQ,EACR,aAAa,EACb,aAAa,EACb,eAAe,EACf,oBAAoB,EACpB,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EAEnB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,cAAc,GACf,MAAM,SAAS,CAAA;AAGhB,OAAO,EACL,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,UAAU,GACX,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,GACf,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EACL,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,YAAY,GACb,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,YAAY,GACb,MAAM,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,wBAAwB,GAC9B,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,qBAAqB,EACrB,KAAK,mBAAmB,GACzB,MAAM,0BAA0B,CAAA;AAEjC,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAE3C,OAAO,EACL,kBAAkB,EAClB,cAAc,IAAI,mBAAmB,EACrC,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACT,WAAW,EACX,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,gBAAgB,GACtB,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GACnB,MAAM,iBAAiB,CAAA;AAGxB,YAAY,EACV,gBAAgB,EAChB,sBAAsB,EACtB,WAAW,EACX,MAAM,EACN,QAAQ,EACR,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EAClB,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,aAAa,EACb,aAAa,EACb,QAAQ,EACR,aAAa,EACb,aAAa,EACb,eAAe,EACf,oBAAoB,EACpB,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EAEnB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,cAAc,GACf,MAAM,SAAS,CAAA;AAGhB,OAAO,EACL,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,UAAU,GACX,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,GACf,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EACL,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,YAAY,GACb,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,YAAY,GACb,MAAM,mBAAmB,CAAA"}

package/dist/prices/oracle-prices/lenderKeys.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Collapse a market-keyed lender key to its protocol family:
+ * `MORPHO_BLUE_<id>` / `AAVE_V4_<spoke>` / `SILO_V2_<silo>` -> `MORPHO_BLUE`,
+ * `AAVE_V4`, `SILO_V2`.
+ *
+ * Used wherever INDEPENDENT sources are counted. One protocol emitting a
+ * price per market must not look like agreement between many protocols —
+ * that is the difference between "four oracles agree" and "one oracle, read
+ * four times".
+ *
+ * Suffixes that are not pure hex (`COMPOUND_V3_USDC`, `AAVE_V3_ETHER_FI`)
+ * are distinct deployments and keep their key.
+ *
+ * Lives in its own module so `feedStats` and `selectAssetGroupPrices` can
+ * both use it without an import cycle.
+ */
+export declare function lenderFamily(lender: string): string;
+//# sourceMappingURL=lenderKeys.d.ts.map

package/dist/prices/oracle-prices/lenderKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lenderKeys.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/lenderKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/prices/oracle-prices/outlierGuard.d.ts

@@ -0,0 +1,43 @@
+import { OutlierGuardConfig } from './types';
+/**
+ * Cross-source consensus: the one signal that works on oracles exposing no
+ * timestamp at all (Compound V2 forks return a bare `getUnderlyingPrice`,
+ * Morpho a bare `price()`), where a dead feed is indistinguishable from a
+ * live one on-chain.
+ *
+ * Shared by the selection guard and by the feed-reliability stats so BOTH
+ * apply the same standard of proof. Learning "this feed disagrees" from a
+ * two-source group would be the same mistake as rejecting on it.
+ */
+export declare const DEFAULT_OUTLIER_GUARD: OutlierGuardConfig;
+export declare function median(values: number[]): number;
+/** Anything carrying a price and the identity of the source behind it. */
+export interface FeedPriced {
+    priceUSD: number;
+    feedKey: string;
+}
+/**
+ * The reference price a group agrees on, or `undefined` when the group has
+ * no broad agreement.
+ *
+ * The reference is the median of PER-FEED medians, so the five protocols
+ * reading one Chainlink aggregator count once, not five times, and a
+ * protocol emitting a price per market cannot outvote everyone else.
+ *
+ * Requiring a real cluster is what stops a minority of broken feeds from
+ * overruling a correct price: where two dead feeds quote a `1e-8` sentinel
+ * and only AAVE quotes the truth, no cluster forms and the caller is told
+ * there is no consensus — rather than being handed `1e-8` as one.
+ */
+export declare function consensusReference(candidates: FeedPriced[], guard?: OutlierGuardConfig): number | undefined;
+/**
+ * Drop candidates that contradict a strong cross-feed consensus.
+ *
+ * Rejects on a FACTOR (default >2x off), never on a percentage, so ordinary
+ * oracle disagreement is untouched — and never empties a group.
+ *
+ * Exported so tests can assert against the real implementation instead of a
+ * copy that can drift from it.
+ */
+export declare function rejectOutliers<T extends FeedPriced>(candidates: T[], guard?: OutlierGuardConfig): T[];
+//# sourceMappingURL=outlierGuard.d.ts.map

package/dist/prices/oracle-prices/outlierGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outlierGuard.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/outlierGuard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE5C;;;;;;;;;GASG;AAEH,eAAO,MAAM,qBAAqB,EAAE,kBAInC,CAAA;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAI/C;AAED,0EAA0E;AAC1E,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EAAE,EACxB,KAAK,GAAE,kBAA0C,GAChD,MAAM,GAAG,SAAS,CAqBpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,UAAU,EACjD,UAAU,EAAE,CAAC,EAAE,EACf,KAAK,GAAE,kBAA0C,GAChD,CAAC,EAAE,CAUL"}

package/dist/prices/oracle-prices/selectAssetGroupPrices.d.ts

@@ -1,10 +1,51 @@
 import { TokenListInput } from './fetchOraclePrices';
-import { StructuredOraclePrices, USDPriceMap, FlattenPriorityConfig, TvlMap } from './types';
+import { StructuredOraclePrices, USDPriceMap, FlattenPriorityConfig, TvlMap, DepthMap, PriceSelection } from './types';
+import { FeedStatsMap } from './feedStats';
+/**
+ * Feeds older than this are demoted below every fresh candidate, when the
+ * feed has no learned cadence of its own yet.
+ *
+ * 48h = 2x the slowest standard Chainlink heartbeat (24h). A healthy
+ * stablecoin feed on a 24h heartbeat is routinely 10-20h old, so anything
+ * tighter would demote perfectly good prices. Once `feedStats` has watched a
+ * feed for a few updates, its own cadence replaces this constant.
+ */
+export declare const DEFAULT_STALE_REJECT_SECONDS = 172800;
+export { DEFAULT_OUTLIER_GUARD } from './outlierGuard';
+/** Options for the evidence-driven tiers. */
+export interface SelectPricesOptions {
+    /**
+     * Market depth behind each price, keyed by `marketUid`
+     * (`LENDER:chainId:asset`) or, for the legacy shape, by lender.
+     * Orders the long tail of lenders that no priority list mentions — without
+     * it, ties there fall through to the deterministic identity tiebreak.
+     */
+    depth?: DepthMap | TvlMap;
+    /** Learned per-feed cadence + agreement stats from `feedStats.ts` */
+    feedStats?: FeedStatsMap;
+    /** Wall clock override (unix seconds), for deterministic tests */
+    nowSeconds?: number;
+    /**
+     * Receives the winning candidate per asset group. Provenance is otherwise
+     * unrecoverable from the flat map — "why is AVAX $23.78" should not
+     * require re-deriving the whole pipeline.
+     */
+    onSelection?: (selection: PriceSelection) => void;
+}
 /**
  * Flattens structured oracle prices to a simple USD price map.
  *
- * When multiple oracles report a price for the same assetGroup the
- * priority config decides which one wins (first-write-wins after sorting).
+ * Ranking, in order:
+ *   1. freshness   — past this feed's own learned cadence loses
+ *   2. reliability — a feed that habitually disagrees with the market loses
+ *   3. derivation  — a direct oracle read beats a price derived from one
+ *   4. lender      — operator preference from the priority config
+ *   5. depth       — deeper market wins (also picks an asset's home chain)
+ *   6. chain       — configured chain preference
+ *   7. identity    — deterministic, never input order
+ *
+ * Before ranking, candidates contradicting a strong cross-feed consensus are
+ * dropped by the outlier guard.
  */
-export declare function selectAssetGroupPrices(structuredPrices: StructuredOraclePrices, lists?: TokenListInput, tvlMap?: TvlMap, priorityCfg?: FlattenPriorityConfig): USDPriceMap;
+export declare function selectAssetGroupPrices(structuredPrices: StructuredOraclePrices, lists?: TokenListInput, depthOrTvl?: DepthMap | TvlMap, priorityCfg?: FlattenPriorityConfig, options?: SelectPricesOptions): USDPriceMap;
 //# sourceMappingURL=selectAssetGroupPrices.d.ts.map

package/dist/prices/oracle-prices/selectAssetGroupPrices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selectAssetGroupPrices.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/selectAssetGroupPrices.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EACL,sBAAsB,EACtB,WAAW,EACX,qBAAqB,EACrB,MAAM,EACP,MAAM,SAAS,CAAA;AAoFhB;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,sBAAsB,EACxC,KAAK,GAAE,cAAmB,EAC1B,MAAM,GAAE,MAAW,EACnB,WAAW,GAAE,qBAAwC,GACpD,WAAW,CA0Cb"}
+{"version":3,"file":"selectAssetGroupPrices.d.ts","sourceRoot":"","sources":["../../../src/prices/oracle-prices/selectAssetGroupPrices.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EACL,sBAAsB,EACtB,WAAW,EACX,qBAAqB,EAErB,MAAM,EACN,QAAQ,EAER,cAAc,EACf,MAAM,SAAS,CAAA;AAKhB,OAAO,EACL,YAAY,EAOb,MAAM,aAAa,CAAA;AAMpB;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,SAAU,CAAA;AASnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AA2KtD,6CAA6C;AAC7C,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAA;IACzB,qEAAqE;IACrE,SAAS,CAAC,EAAE,YAAY,CAAA;IACxB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,cAAc,KAAK,IAAI,CAAA;CAClD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,sBAAsB,EACxC,KAAK,GAAE,cAAmB,EAC1B,UAAU,GAAE,QAAQ,GAAG,MAAW,EAClC,WAAW,GAAE,qBAAwC,EACrD,OAAO,GAAE,mBAAwB,GAChC,WAAW,CA8Fb"}

package/dist/prices/oracle-prices/types.d.ts

@@ -29,7 +29,45 @@ export interface OraclePriceEntry {
      * `undefined` means the price is config-agnostic (all other lenders).
      */
     configId?: string;
+    /**
+     * Unix seconds of the feed's last update, when the oracle exposes one
+     * (Chainlink-style `latestRoundData().updatedAt`).
+     *
+     * Set directly by fetchers that read round data (Compound V3) and
+     * back-filled for AAVE-family entries by the source probe in
+     * `feedStaleness.ts`. `undefined` means the oracle has no readable
+     * timestamp (e.g. Compound V2 `getUnderlyingPrice`, Morpho `price()`)
+     * — NOT that the feed is fresh. Staleness for those oracles can only be
+     * caught by the cross-source outlier guard in `selectAssetGroupPrices`.
+     */
+    updatedAt?: number;
+    /** Feed address the `updatedAt` was read from (diagnostics only) */
+    feedSource?: string;
+    /**
+     * How this USD price was obtained. The single highest-signal ranking input:
+     * a derived price inherits the error of whatever it was derived from and
+     * can never be better than it, so it must lose to a direct oracle read.
+     *
+     * Set by the fetcher (or defaulted per fetcher group in
+     * `fetchOraclePrices`); resolved with `resolveDerivation` so legacy or
+     * third-party entries still classify sensibly from `baseAsset`/`staticBase`.
+     */
+    derivation?: PriceDerivation;
 }
+/**
+ * Quality class of a USD price, in descending order of trust.
+ *
+ * - `direct` — the oracle returns USD (or the asset IS the base and prices
+ *   itself at 1). No dependency on any other price.
+ * - `quoted` — a real feed for this asset denominated in another asset
+ *   (e.g. `cbBTC / ETH`), multiplied by that asset's USD price. One
+ *   dependency, but the asset itself has a dedicated feed.
+ * - `derived` — no feed for this asset at all: a market ratio
+ *   (Morpho `price()`, Fluid/Silo/Teller/Gearbox exchange ratios)
+ *   multiplied by another asset's USD. Error compounds and the result is
+ *   only as good as the leg it hangs off.
+ */
+export type PriceDerivation = 'direct' | 'quoted' | 'derived';
 /**
  * Structured oracle price data
  * chainId -> lender -> array of price entries
@@ -258,11 +296,84 @@ export interface FlattenPriorityConfig {
     excludedLendersPerChain: {
         [chainId: string]: string[];
     };
+    /**
+     * Entries whose `updatedAt` is older than this many seconds are demoted
+     * below every fresh candidate (they still fill gaps when nothing else
+     * prices the asset). Default `DEFAULT_STALE_REJECT_SECONDS` (48h).
+     *
+     * Deliberately far above the reporting threshold in `fetchOraclePrices`:
+     * the slowest standard Chainlink heartbeat is 24h, so a healthy stablecoin
+     * feed is routinely several hours old and must NOT be demoted.
+     * Set to 0 to disable staleness demotion.
+     */
+    staleRejectSeconds?: number;
+    /**
+     * Cross-source sanity guard. When several independent protocol families
+     * agree on a price, candidates that disagree by more than
+     * `rejectFactor` are dropped before priority is applied — this is the only
+     * defense against oracles that expose no timestamp (Compound V2 forks,
+     * Morpho `price()`), where a dead feed is indistinguishable from a live
+     * one on-chain. Set to `false` to disable.
+     */
+    outlierGuard?: OutlierGuardConfig | false;
 }
-/** TVL map keyed by lender -> total liquidity USD */
+/**
+ * Cross-source outlier rejection settings.
+ *
+ * Deliberately conservative: it only fires when a large majority of
+ * INDEPENDENT protocol families agree, and only drops candidates that are
+ * off by a factor, not a percentage. A minority of broken feeds must never
+ * be able to reject a correct price.
+ */
+export interface OutlierGuardConfig {
+    /**
+     * Minimum number of distinct protocol families that must agree (within
+     * `agreementTolerance` of the reference price) before any candidate is
+     * dropped. Below this the group is left untouched.
+     */
+    minAgreeingFamilies: number;
+    /** Relative tolerance for counting a family as "agreeing" (0.05 = 5%) */
+    agreementTolerance: number;
+    /**
+     * Multiplicative deviation from the reference price above which a
+     * candidate is rejected (2 = more than 2x or less than half).
+     */
+    rejectFactor: number;
+}
+/** TVL map keyed by lender -> total liquidity USD (legacy shape) */
 export type TvlMap = {
     [lender: string]: number;
 };
+/**
+ * Market depth behind a price, keyed by `marketUid`
+ * (`LENDER:chainId:asset`, see `createMarketUid`) — the same key the lending
+ * pipeline already uses, so producers can join the two without a new
+ * identifier.
+ *
+ * Accepts lender-level keys too, so the legacy `TvlMap` keeps working: the
+ * per-market key is tried first and the lender key is the fallback.
+ */
+export type DepthMap = {
+    [marketUidOrLender: string]: number;
+};
+/**
+ * Why a given asset group ended up with the price it did. Emitted per group
+ * via `SelectPricesOptions.onSelection` — the flat price map alone makes
+ * "where did this number come from" unanswerable.
+ */
+export interface PriceSelection {
+    assetGroup: string;
+    priceUSD: number;
+    chainId: string;
+    lender: string;
+    /** Aggregator address, or `lender|asset` when the oracle exposes none */
+    feedKey: string;
+    derivation: PriceDerivation;
+    /** Candidates considered for this group */
+    candidates: number;
+    /** How many the outlier guard dropped */
+    rejected: number;
+}
 /**
  * Per-tracker diagnostics (one entry per fetcher/lender per chain)
  */
@@ -317,6 +428,8 @@ export interface StaleFeedEntry {
     oracle: string;
     /** Seconds since the feed was last updated */
     staleSeconds: number;
+    /** Feed description when the aggregator exposes one (e.g. "EURC / USD") */
+    description?: string;
 }
 /**
  * Top-level diagnostics report returned alongside oracle prices