@1delta/margin-fetcher 0.0.246 → 0.0.250

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

@@ -0,0 +1,91 @@
+import { ListaMarketOverride, FetcherResult, OraclePriceEntry, ParseContext } from '../types';
+/**
+ * Market overrides for extending Lista markets beyond JSON data
+ */
+export type ListaMarketOverrides = {
+    [chainId: string]: ListaMarketOverride[];
+};
+/**
+ * Context for Lista fetcher with optional market overrides
+ */
+export interface ListaFetcherContext {
+    marketOverrides?: ListaMarketOverrides;
+}
+/**
+ * Internal market structure for Lista
+ */
+interface ListaMarket {
+    oracle: string;
+    collateralAsset: string;
+    loanAsset: string;
+    marketId: string;
+}
+/**
+ * Grouped metadata for deduplicated oracle calls
+ * Deduplicates at the (oracle, asset) level since peek(asset) returns the same result
+ */
+interface ListaGroupedMeta {
+    /** Map from "oracleLc:assetLc" key to index in the calls array */
+    callIndexMap: {
+        [key: string]: number;
+    };
+    /** All markets to process */
+    markets: ListaMarket[];
+}
+/**
+ * Get multicall calls for Lista oracles
+ * Deduplicates peek(asset) calls at the (oracle, asset) level.
+ * Returns a single FetcherResult with all unique calls and market mappings.
+ *
+ * @param chainId - Chain ID to get calls for
+ * @param context - Optional context with market overrides
+ */
+export declare function getListaCalls(chainId: string, context?: ListaFetcherContext): FetcherResult<ListaGroupedMeta>[];
+/**
+ * Parse Lista oracle results into structured price entries
+ *
+ * Processes all markets using the deduplicated call results.
+ * Each entry gets a targetLender so it routes to the correct per-market lender key.
+ *
+ * Lista oracles return USD prices directly via peek(asset)
+ * Prices are in 8 decimals (same as Chainlink)
+ */
+export declare function parseListaResults(data: any[], meta: ListaGroupedMeta, context: ParseContext): OraclePriceEntry[];
+/**
+ * Get ABI for Lista oracle calls
+ */
+export declare function getListaAbi(): readonly [{
+    readonly inputs: readonly [];
+    readonly name: "price";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly name: "peek";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+/**
+ * Lista Oracle Fetcher module
+ */
+export declare const listaFetcher: {
+    getCalls: typeof getListaCalls;
+    parse: typeof parseListaResults;
+    getAbi: typeof getListaAbi;
+};
+export {};
+//# sourceMappingURL=lista.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lista.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/lista.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,mBAAmB,EACnB,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAMjB;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,EAAE,CAAA;CACzC,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,oBAAoB,CAAA;CACvC;AAED;;GAEG;AACH,UAAU,WAAW;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,MAAM,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;;GAGG;AACH,UAAU,gBAAgB;IACxB,kEAAkE;IAClE,YAAY,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;IACvC,6BAA6B;IAC7B,OAAO,EAAE,WAAW,EAAE,CAAA;CACvB;AAwCD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,mBAAmB,GAC5B,aAAa,CAAC,gBAAgB,CAAC,EAAE,CAwCnC;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CA2CpB;AAED;;GAEG;AACH,wBAAgB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;GAE1B;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;;;CAIxB,CAAA"}

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

@@ -0,0 +1,95 @@
+import { MorphoQueryMeta, MorphoMarketOverride, FetcherResult, OraclePriceEntry, ParseContext } from '../types';
+/**
+ * Check if the Morpho GraphQL API is available for a given chain.
+ * Some chains are not indexed by the Morpho API.
+ *
+ * Callers use this to classify chains into two strict modes:
+ *   - available → API only (ignore overrides)
+ *   - unavailable → on-chain from overrides only (skip API)
+ */
+export declare function morphoApiAvailable(chainId: string): boolean;
+/**
+ * Market overrides for extending Morpho markets beyond JSON data
+ */
+export type MorphoMarketOverrides = {
+    [chainId: string]: MorphoMarketOverride[];
+};
+/**
+ * Grouped metadata for deduplicated oracle calls
+ * Multiple markets can share the same oracle — one call, many markets
+ */
+interface MorphoGroupedMeta {
+    markets: MorphoQueryMeta[];
+}
+/**
+ * Context for Morpho fetcher with optional market overrides
+ */
+export interface MorphoFetcherContext {
+    marketOverrides?: MorphoMarketOverrides;
+}
+/**
+ * Get multicall calls for Morpho oracles
+ * Groups markets by oracle address to deduplicate price() calls.
+ * Each entry in the result still maps back to individual markets via targetLender.
+ *
+ * @param chainId - Chain ID to get calls for
+ * @param context - Optional context with market overrides
+ */
+export declare function getMorphoCalls(chainId: string, context?: MorphoFetcherContext): FetcherResult<MorphoGroupedMeta>[];
+/**
+ * Parse Morpho oracle results into structured price entries
+ *
+ * Processes all markets sharing the same oracle with a single price() result.
+ * Each entry gets a targetLender so it routes to the correct per-market lender key.
+ *
+ * Morpho oracles return price of collateral in terms of loan asset (debt).
+ * To get USD price:
+ * - If we know loan asset USD price: collateralUSD = priceDebtToCollateral * loanAssetUSD
+ * - If we know collateral USD price: loanAssetUSD = collateralUSD / priceDebtToCollateral
+ */
+export declare function parseMorphoResults(data: any[], meta: MorphoGroupedMeta, context: ParseContext): OraclePriceEntry[];
+/**
+ * Get ABI for Morpho oracle calls
+ */
+export declare function getMorphoAbi(): readonly [{
+    readonly inputs: readonly [];
+    readonly name: "price";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly name: "peek";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+/**
+ * Fetch Morpho oracle prices from the GraphQL API instead of on-chain calls.
+ * Returns OraclePriceEntry[] directly, or null if the API is unavailable.
+ *
+ * This avoids hundreds of on-chain price() calls on chains where the API is available.
+ */
+export declare function fetchMorphoGraphQLPrices(chainId: string): Promise<OraclePriceEntry[] | null>;
+/**
+ * Morpho Oracle Fetcher module
+ */
+export declare const morphoFetcher: {
+    getCalls: typeof getMorphoCalls;
+    parse: typeof parseMorphoResults;
+    getAbi: typeof getMorphoAbi;
+};
+export {};
+//# sourceMappingURL=morpho.d.ts.map

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

@@ -0,0 +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;AAQjB;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAS3D;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;AA+CD;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,gBAAgB,EAAE,GAAG,IAAI,CAAC,CA4DpC;AA+JD;;GAEG;AACH,eAAO,MAAM,aAAa;;;;CAIzB,CAAA"}

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

@@ -0,0 +1,108 @@
+import type { FetcherResult, OraclePriceEntry, ParseContext } from '../types';
+/**
+ * Metadata carried alongside the multicall batch so the parser can
+ * reassemble results without re-reading on-chain state.
+ */
+interface SiloV2OracleMeta {
+    /** Entries to process, one per silo half */
+    entries: {
+        token: string;
+        decimals: number;
+        silo: string;
+        lenderKey: string;
+        oracle: string;
+        /** Other half's token — used for 1:1 fallback when this side is static */
+        partnerToken: string;
+        /**
+         * True when this side has a zero-address oracle (constant price = 1.0).
+         * Treated like a Morpho loan asset: priced via the partner token's USD
+         * (or its own, if independently known) and flagged with `staticBase`.
+         */
+        isStatic: boolean;
+    }[];
+    /**
+     * Dedup map: "oracleLc:tokenLc" → index into the calls array.
+     * The same oracle+token pair only needs one `quote` call even if it
+     * appears in multiple markets.
+     */
+    callIndexMap: {
+        [key: string]: number;
+    };
+    /**
+     * "oracleLc" → index of the quoteToken() call for that oracle.
+     */
+    quoteTokenIndexMap: {
+        [key: string]: number;
+    };
+}
+/**
+ * Build multicall calls for all Silo V2 oracle prices on the given chain.
+ *
+ * Three cases per pair:
+ *   1. Both halves have a real oracle → standard `quote` + `quoteToken` calls.
+ *   2. Exactly one half is zero-address (constant = 1.0) → emit that side as
+ *      `staticBase` (priced via the partner token's USD) and run the normal
+ *      flow on the other side. The non-static oracle is expected to quote in
+ *      the static side's token, so the existing `quote * qtUSD` math just
+ *      works once the partner USD price is in `usdPrices`.
+ *   3. Both halves are zero-address → the pair is 1:1 in its own terms. Only
+ *      emit if at least one of the two tokens has a real oracle elsewhere on
+ *      the chain (e.g. WBTC priced by another silo); otherwise (the WBTC-LBTC
+ *      case where neither has a non-constant feed) skip the pair entirely.
+ *
+ * Calls are deduplicated at the (oracle, token) level for `quote` and at
+ * the oracle level for `quoteToken`.
+ */
+export declare function getSiloV2Calls(chainId: string): FetcherResult<SiloV2OracleMeta>[];
+/**
+ * Parse Silo V2 oracle multicall results into price entries.
+ *
+ * Static halves (zero-address oracle) are resolved by looking up the USD
+ * price of the side's own token, falling back to the partner token (the
+ * relationship is 1:1 by definition). They are flagged with `staticBase`
+ * + `baseAsset = self`, mirroring the Morpho loan-asset entries.
+ *
+ * Non-static halves use `quote(1.0, token) → priceInQuoteToken × qtUSD`.
+ * When the static side's token IS the partner oracle's quoteToken, the
+ * non-static math automatically picks up the right USD via the shared
+ * `usdPrices` map (populated by other lenders earlier in the parse order).
+ */
+export declare function parseSiloV2Results(data: any[], meta: SiloV2OracleMeta, context: ParseContext): OraclePriceEntry[];
+/**
+ * ABI fragments needed for Silo V2 oracle calls
+ */
+export declare function getSiloV2Abi(): readonly [{
+    readonly inputs: readonly [{
+        readonly name: "_baseAmount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_baseToken";
+        readonly type: "address";
+    }];
+    readonly name: "quote";
+    readonly outputs: readonly [{
+        readonly name: "quoteAmount";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "quoteToken";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+/**
+ * Silo V2 Oracle Fetcher module
+ */
+export declare const siloV2Fetcher: {
+    getCalls: typeof getSiloV2Calls;
+    parse: typeof parseSiloV2Results;
+    getAbi: typeof getSiloV2Abi;
+};
+export {};
+//# sourceMappingURL=siloV2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"siloV2.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/siloV2.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAgCjB;;;GAGG;AACH,UAAU,gBAAgB;IACxB,4CAA4C;IAC5C,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAA;QACb,QAAQ,EAAE,MAAM,CAAA;QAChB,IAAI,EAAE,MAAM,CAAA;QACZ,SAAS,EAAE,MAAM,CAAA;QACjB,MAAM,EAAE,MAAM,CAAA;QACd,0EAA0E;QAC1E,YAAY,EAAE,MAAM,CAAA;QACpB;;;;WAIG;QACH,QAAQ,EAAE,OAAO,CAAA;KAClB,EAAE,CAAA;IACH;;;;OAIG;IACH,YAAY,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;IACvC;;OAEG;IACH,kBAAkB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;CAC9C;AAUD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,gBAAgB,CAAC,EAAE,CAoGnC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CA+EpB;AAED;;GAEG;AACH,wBAAgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;GAE3B;AAED;;GAEG;AACH,eAAO,MAAM,aAAa;;;;CAIzB,CAAA"}

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

@@ -0,0 +1,54 @@
+import { type SiloApiEntry } from '../../../lending/public-data/silo-v2/fetchPublic';
+import type { OraclePriceEntry, ParseContext, TokenListMap, USDPriceMap } from '../types';
+/**
+ * Narrowed Silo v2 oracle-price prefetch via `api-v3.silo.finance`.
+ *
+ * The `silos.market{1,2}.solvencyOracle.quote` field already exposes the
+ * same "1 baseToken in quoteToken units" value the on-chain `ISiloOracle.quote`
+ * call produces, so when the indexer has data for a chain we can skip the
+ * Silo v2 multicall entirely and emit the price entries from the GraphQL
+ * response instead.
+ *
+ * This mirrors the Morpho GraphQL prefetch in `morpho.ts`: the prefetch
+ * runs in parallel with the on-chain multicall, and the caller decides —
+ * after both are settled — which source to feed into the parse pipeline.
+ *
+ * Returns `null` when the indexer has no data for the chain (caller must
+ * fall back to on-chain) and throws on transport / GraphQL errors so the
+ * caller can log and fall back.
+ */
+export declare function fetchSiloV2GraphQLMarkets(chainId: string): Promise<SiloApiEntry[] | null>;
+/**
+ * Morpho-style one-shot price fetcher: returns parsed `OraclePriceEntry[]`
+ * (or `null` to signal "fall back to on-chain") in a single call.
+ *
+ * Self-contained — does NOT depend on prices populated by other lender
+ * parsers. Empty silos that need a quote-token USD lookup are resolved
+ * against the union of:
+ *   1. USD prices self-derived from `supplyUsd / supply` across every
+ *      non-empty silo half in the same GraphQL response (covers USDC,
+ *      USDT, WETH, etc. since they show up as widely deposited assets).
+ *   2. The caller-provided `basePrices` map (from `fetchOraclePrices`'s
+ *      `basePrices` option).
+ *
+ * Mirrors `fetchMorphoGraphQLPrices` so the caller can treat both
+ * protocols uniformly: parallel fetch, push entries directly, fall back
+ * to the on-chain multicall when this returns `null`.
+ */
+export declare function fetchSiloV2GraphQLPrices(chainId: string, basePrices?: USDPriceMap, tokenList?: TokenListMap): Promise<OraclePriceEntry[] | null>;
+/**
+ * Convert a GraphQL-fetched silos list into oracle price entries.
+ *
+ * For each silo half:
+ *  - If the solvencyOracle is the zero address → emit a `staticBase` entry
+ *    priced via the partner token's USD (mirrors the on-chain parser).
+ *  - Otherwise, `priceUSD = Number(quote) * quoteTokenUSD`. The raw price
+ *    surfaced to consumers is `Number(quote)` so downstream math matches
+ *    the on-chain output.
+ *
+ * Entries whose quote token has no resolved USD are skipped — the parse
+ * order in `fetchOraclePrices.ts` must run this AFTER the base-USD tier
+ * (Aave / Chainlink / Compound) so the cross-asset prices are available.
+ */
+export declare function parseSiloV2GraphQLResults(items: SiloApiEntry[], context: ParseContext): OraclePriceEntry[];
+//# sourceMappingURL=siloV2Graphql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"siloV2Graphql.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/siloV2Graphql.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,kDAAkD,CAAA;AACzD,OAAO,KAAK,EACV,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,WAAW,EACZ,MAAM,UAAU,CAAA;AAEjB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,CAYhC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,UAAU,GAAE,WAAgB,EAC5B,SAAS,GAAE,YAAiB,GAC3B,OAAO,CAAC,gBAAgB,EAAE,GAAG,IAAI,CAAC,CAcpC;AA2ED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,YAAY,EAAE,EACrB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CA8HpB"}

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

@@ -0,0 +1,52 @@
+import type { FetcherResult, OraclePriceEntry, ParseContext } from '../types';
+interface SiloV3OracleMeta {
+    entries: {
+        token: string;
+        decimals: number;
+        silo: string;
+        lenderKey: string;
+        oracle: string;
+        partnerToken: string;
+        isStatic: boolean;
+    }[];
+    callIndexMap: {
+        [key: string]: number;
+    };
+    quoteTokenIndexMap: {
+        [key: string]: number;
+    };
+}
+export declare function getSiloV3Calls(chainId: string): FetcherResult<SiloV3OracleMeta>[];
+export declare function parseSiloV3Results(data: any[], meta: SiloV3OracleMeta, context: ParseContext): OraclePriceEntry[];
+export declare function getSiloV3Abi(): readonly [{
+    readonly inputs: readonly [{
+        readonly name: "_baseAmount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_baseToken";
+        readonly type: "address";
+    }];
+    readonly name: "quote";
+    readonly outputs: readonly [{
+        readonly name: "quoteAmount";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "quoteToken";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+export declare const siloV3Fetcher: {
+    getCalls: typeof getSiloV3Calls;
+    parse: typeof parseSiloV3Results;
+    getAbi: typeof getSiloV3Abi;
+};
+export {};
+//# sourceMappingURL=siloV3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"siloV3.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/siloV3.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAmCjB,UAAU,gBAAgB;IACxB,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAA;QACb,QAAQ,EAAE,MAAM,CAAA;QAChB,IAAI,EAAE,MAAM,CAAA;QACZ,SAAS,EAAE,MAAM,CAAA;QACjB,MAAM,EAAE,MAAM,CAAA;QACd,YAAY,EAAE,MAAM,CAAA;QACpB,QAAQ,EAAE,OAAO,CAAA;KAClB,EAAE,CAAA;IACH,YAAY,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;IACvC,kBAAkB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;CAC9C;AASD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,gBAAgB,CAAC,EAAE,CA8FnC;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CAwEpB;AAED,wBAAgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;GAE3B;AAED,eAAO,MAAM,aAAa;;;;CAIzB,CAAA"}

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

@@ -0,0 +1,30 @@
+import { type SiloApiEntry } from '../../../lending/public-data/silo-v2/fetchPublic';
+import type { OraclePriceEntry, ParseContext, TokenListMap, USDPriceMap } from '../types';
+/**
+ * Silo v3 GraphQL oracle-price prefetch. Mirrors `siloV2Graphql.ts` but
+ * filters the shared `api-v3.silo.finance` endpoint to `protocolVersion:
+ * 'v3'` and looks up registry entries via `getSiloV3MarketEntry`.
+ *
+ * Returns `null` when the indexer has no data for the chain so the caller
+ * can fall back to the on-chain path.
+ */
+export declare function fetchSiloV3GraphQLMarkets(chainId: string): Promise<SiloApiEntry[] | null>;
+/**
+ * Morpho-style one-shot price fetcher for Silo v3. Same self-contained
+ * resolution strategy as the v2 variant: parses with a USD-price map
+ * derived from `supplyUsd / supply` ratios across the same response,
+ * with the caller-provided `basePrices` overlaid on top.
+ *
+ * Mirrors `fetchMorphoGraphQLPrices` so callers can treat this as a
+ * direct, parallel-runnable price source: returns parsed entries on
+ * success or `null` to signal "fall back to on-chain".
+ */
+export declare function fetchSiloV3GraphQLPrices(chainId: string, basePrices?: USDPriceMap, tokenList?: TokenListMap): Promise<OraclePriceEntry[] | null>;
+/**
+ * Convert a GraphQL-fetched silos list into oracle price entries. Logic
+ * identical to the v2 variant — resolves USD via the indexer's
+ * `supplyUsd`/`supply` ratio first, falling back to `quote × quoteTokenUSD`
+ * for empty silos.
+ */
+export declare function parseSiloV3GraphQLResults(items: SiloApiEntry[], context: ParseContext): OraclePriceEntry[];
+//# sourceMappingURL=siloV3Graphql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"siloV3Graphql.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/siloV3Graphql.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,kDAAkD,CAAA;AACzD,OAAO,KAAK,EACV,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,WAAW,EACZ,MAAM,UAAU,CAAA;AAEjB;;;;;;;GAOG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,CAYhC;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,UAAU,GAAE,WAAgB,EAC5B,SAAS,GAAE,YAAiB,GAC3B,OAAO,CAAC,gBAAgB,EAAE,GAAG,IAAI,CAAC,CAcpC;AAwED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,YAAY,EAAE,EACrB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CA8GpB"}

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

@@ -0,0 +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 { aaveFetcher, getAaveCalls, parseAaveResults, getAaveAbi, } from './fetchers/aave';
+export { morphoFetcher, getMorphoCalls, parseMorphoResults, getMorphoAbi, fetchMorphoGraphQLPrices, type MorphoMarketOverrides, type MorphoFetcherContext, } from './fetchers/morpho';
+export { compoundV2Fetcher, getCompoundV2Calls, parseCompoundV2Results, getCompoundV2Abi, CompoundV2OracleAbi, } from './fetchers/compoundV2';
+export { compoundV3Fetcher, getCompoundV3Calls, parseCompoundV3Results, getCompoundV3Abi, ChainlinkAggregatorAbi, } from './fetchers/compoundV3';
+export { listaFetcher, getListaCalls, parseListaResults, getListaAbi, type ListaMarketOverrides, type ListaFetcherContext, } from './fetchers/lista';
+export { siloV2Fetcher, getSiloV2Calls, parseSiloV2Results, getSiloV2Abi, } from './fetchers/siloV2';
+export { siloV3Fetcher, getSiloV3Calls, parseSiloV3Results, getSiloV3Abi, } from './fetchers/siloV3';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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,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/selectAssetGroupPrices.d.ts

@@ -0,0 +1,10 @@
+import { TokenListInput } from './fetchOraclePrices';
+import { StructuredOraclePrices, USDPriceMap, FlattenPriorityConfig, TvlMap } from './types';
+/**
+ * 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).
+ */
+export declare function selectAssetGroupPrices(structuredPrices: StructuredOraclePrices, lists?: TokenListInput, tvlMap?: TvlMap, priorityCfg?: FlattenPriorityConfig): USDPriceMap;
+//# sourceMappingURL=selectAssetGroupPrices.d.ts.map

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

@@ -0,0 +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"}