@1delta/margin-fetcher 0.0.341 → 0.0.342

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

@@ -1,73 +0,0 @@
-import { FetcherResult, OraclePriceEntry, ParseContext } from '../types';
-/**
- * Liquity-family oracle price fetcher (Liquity V2 + friendly forks: Felix,
- * USDaf, Nerite, Quill, Enosys, Soneta, Ebisu).
- *
- * Each branch's `PriceFeed.lastGoodPrice()` returns the COLLATERAL price in USD
- * (1e18-scaled on canonical 18-dec collateral; see `liquityCollateralPrice` for
- * the fork-dependent scale on non-18-dec branches) — the same value the branch
- * uses for its collateral ratio, and the same read the public-data fetcher
- * already makes. So these are DIRECT USD prices (PASS 1) that feed the shared
- * `usdPrices` map.
- *
- * Why a dedicated fetcher (not cross-protocol flattening): the family spans
- * chains where no other integrated protocol prices the collateral (Felix/HYPE
- * on HyperEVM, Enosys on Flare, Soneta on Sonic, Ebisu on Plasma, plus bespoke
- * LST/stable collateral on mainnet). Without this those branches would serve a
- * null oracle price. It also uses each branch's OWN feed — the correct oracle
- * for risk. `lastGoodPrice` is a view (fresh on any active branch), so one call
- * per branch. The stablecoin (BOLD / USDaf / satUSD-like) is the debt asset and
- * is emitted pegged to $1 (the same peg `convertPublic` uses) so debt is priced.
- */
-interface LiquityBranchMeta {
-    lender: string;
-    chainId: string;
-    collIndex: number;
-    collToken: string;
-    /** Collateral token decimals — sets the feed scale (see below). */
-    collDecimals: number;
-    /** Feed decimals from metadata when known; auto-detected otherwise. */
-    priceDecimals?: number;
-    /** Stable/debt token (pegged to 1). Emitted once per branch. */
-    debtToken?: string;
-}
-/** Build one `lastGoodPrice()` call per branch across every family deployment. */
-export declare function getLiquityCalls(chainId: string): FetcherResult<LiquityBranchMeta>[];
-/**
- * Parse a branch's `lastGoodPrice` into direct-USD entries: the collateral at
- * its on-chain USD price, and the stablecoin pegged to $1. Both keyed under the
- * per-branch `<DEPLOYMENT>_<chain>_<collIndex>` lender so the marketUids join
- * the Liquity lending data.
- */
-export declare function parseLiquityResults(data: any[], meta: LiquityBranchMeta, context: ParseContext): OraclePriceEntry[];
-/** ABI for the Liquity oracle call (`lastGoodPrice`). */
-export declare function getLiquityAbi(): readonly [{
-    readonly type: "function";
-    readonly name: "fetchPrice";
-    readonly stateMutability: "nonpayable";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }, {
-        readonly name: "";
-        readonly type: "bool";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "lastGoodPrice";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}];
-/** Liquity-family Oracle Fetcher module. */
-export declare const liquityFetcher: {
-    getCalls: typeof getLiquityCalls;
-    parse: typeof parseLiquityResults;
-    getAbi: typeof getLiquityAbi;
-};
-export {};
-//# sourceMappingURL=liquity.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"liquity.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/liquity.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAOjB;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,mEAAmE;IACnE,YAAY,EAAE,MAAM,CAAA;IACpB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,kFAAkF;AAClF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,iBAAiB,CAAC,EAAE,CA8BpC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CAmDpB;AAED,yDAAyD;AACzD,wBAAgB,aAAa;;;;;;;;;;;;;;;;;;;;;GAE5B;AAED,4CAA4C;AAC5C,eAAO,MAAM,cAAc;;;;CAI1B,CAAA"}

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

@@ -1,91 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/midnight.d.ts

@@ -1,86 +0,0 @@
-import { FetcherResult, OraclePriceEntry, ParseContext } from '../types';
-/**
- * Morpho Midnight oracle price fetcher.
- *
- * Midnight is a fixed-rate, fixed-maturity order-book protocol (NOT a Blue
- * fork), but each collateral leg of a market carries a Morpho-style oracle
- * that implements `price()` with identical scaling — verified on-chain: the
- * raw uint256 is `ratio * 10^(36 + loanDecimals - collateralDecimals)`, the
- * price of the collateral quoted in the loan asset. So the pricing math is
- * the same as `morpho.ts`; only the shape (one loan asset, N collateral legs
- * per market) and the lender key (`MORPHO_MIDNIGHT_<id>`) differ.
- *
- * Entries land under `midnightLenderKey(marketId)` so their marketUids join the
- * Midnight lending data emitted by `convertMidnightMarketsToResponse`.
- *
- * Like Morpho, Midnight prices are DERIVED: the collateral USD price needs the
- * loan asset's USD price from an earlier (Pass 1) parser. Parsed with
- * `updatePrices=false` so derived values don't overwrite direct oracle reads.
- */
-/** One collateral leg of a Midnight market — one `price()` call. */
-interface MidnightLeg {
-    collateralAsset: string;
-    collateralDecimals: number;
-    oracle: string;
-}
-/** Grouped metadata: one Midnight market (loan asset + ordered collateral legs). */
-interface MidnightMarketMeta {
-    marketId: string;
-    loanAsset: string;
-    loanDecimals: number;
-    /** Ordered to match the emitted `price()` calls (index = call slot). */
-    legs: MidnightLeg[];
-}
-/**
- * Build multicall calls for Midnight oracles.
- *
- * One `FetcherResult` per market; its `calls` are the per-leg `price()` reads
- * in collateral-leg order, so the parser can zip results back to legs by index.
- * Legs without a configured oracle are dropped (they can't be priced).
- */
-export declare function getMidnightCalls(chainId: string): FetcherResult<MidnightMarketMeta>[];
-/**
- * Parse Midnight oracle results into structured price entries.
- *
- * Mirrors `parseMorphoResults`: each leg's oracle returns the collateral price
- * in loan-asset terms. USD conversion multiplies that ratio by the loan asset's
- * known USD price. Emits one loan-asset entry per market (price = 1, the
- * oracle's own unit of account) plus one entry per priced collateral leg.
- */
-export declare function parseMidnightResults(data: any[], meta: MidnightMarketMeta, context: ParseContext): OraclePriceEntry[];
-/** ABI for Midnight oracle calls (same `price()` interface as Morpho). */
-export declare function getMidnightAbi(): 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";
-}];
-/**
- * Morpho Midnight Oracle Fetcher module
- */
-export declare const midnightFetcher: {
-    getCalls: typeof getMidnightCalls;
-    parse: typeof parseMidnightResults;
-    getAbi: typeof getMidnightAbi;
-};
-export {};
-//# sourceMappingURL=midnight.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"midnight.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/midnight.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAKjB;;;;;;;;;;;;;;;;;GAiBG;AAEH,oEAAoE;AACpE,UAAU,WAAW;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAA;CACf;AAED,oFAAoF;AACpF,UAAU,kBAAkB;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,wEAAwE;IACxE,IAAI,EAAE,WAAW,EAAE,CAAA;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,kBAAkB,CAAC,EAAE,CAoCrC;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CA0DpB;AAED,0EAA0E;AAC1E,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;GAE7B;AAED;;GAEG;AACH,eAAO,MAAM,eAAe;;;;CAI3B,CAAA"}

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

@@ -1,118 +0,0 @@
-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;
-export declare function morphoApiIncomplete(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";
-}];
-export interface MorphoGqlMarket {
-    uniqueKey: string;
-    oracleAddress: string;
-    loanAsset: {
-        address: string;
-        decimals: number;
-        priceUsd: number | null;
-    };
-    collateralAsset: {
-        address: string;
-        decimals: number;
-        priceUsd: number | null;
-    } | null;
-    state: {
-        price: string | null;
-    } | null;
-}
-/**
- * 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>;
-/**
- * Convert MorphoGqlMarket[] to OraclePriceEntry[].
- * Shared by the Morpho GraphQL and Mystic paths.
- */
-export declare function processMarketsToEntries(chainId: string, allMarkets: MorphoGqlMarket[], source: string): 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

@@ -1 +0,0 @@
-{"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/fetchers/river.d.ts

@@ -1,269 +0,0 @@
-import { FetcherResult, OraclePriceEntry, ParseContext } from '../types';
-/**
- * River (Satoshi rebrand — Liquity V1/Prisma-lineage omni-chain CDP) oracle
- * price fetcher.
- *
- * Each market's `TroveManager.fetchPrice()` returns the COLLATERAL price in USD
- * (1e18-scaled) — the same read the public-data fetcher makes. `fetchPrice` is
- * nonpayable but simulates cleanly under an `eth_call` multicall. Direct USD
- * (PASS 1) → feeds the shared `usdPrices` map, so River collateral on chains
- * where no other integrated protocol prices it (BNB / Base / Hemi bespoke LSTs)
- * is covered from River's own oracle. The debt token (satUSD) is emitted pegged
- * to $1 (matching `convertPublic`).
- */
-interface RiverMarketMeta {
-    lender: string;
-    chainId: string;
-    index: number;
-    collToken: string;
-    debtToken?: string;
-}
-/** Build one `fetchPrice()` call per market across every River deployment. */
-export declare function getRiverCalls(chainId: string): FetcherResult<RiverMarketMeta>[];
-/**
- * Parse a market's `fetchPrice` into direct-USD entries: the collateral at its
- * on-chain USD price, and satUSD pegged to $1. Keyed under the per-market
- * `RIVER_<chain>_<index>` lender.
- */
-export declare function parseRiverResults(data: any[], meta: RiverMarketMeta, context: ParseContext): OraclePriceEntry[];
-/** ABI for the River oracle call (`fetchPrice`). */
-export declare function getRiverAbi(): readonly [{
-    readonly type: "function";
-    readonly name: "getEntireSystemColl";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "getEntireSystemDebt";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "MCR";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "interestRate";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "getBorrowingRateWithDecay";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "borrowingFeeFloor";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "maxBorrowingFee";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "maxSystemDebt";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "debtGasCompensation";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "collateralToken";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "sortedTroves";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "getTroveOwnersCount";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "paused";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "sunsetting";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "fetchPrice";
-    readonly stateMutability: "nonpayable";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "troves";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "debt";
-        readonly type: "uint256";
-    }, {
-        readonly name: "coll";
-        readonly type: "uint256";
-    }, {
-        readonly name: "stake";
-        readonly type: "uint256";
-    }, {
-        readonly name: "status";
-        readonly type: "uint8";
-    }, {
-        readonly name: "arrayIndex";
-        readonly type: "uint128";
-    }, {
-        readonly name: "activeInterestIndex";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "getEntireDebtAndColl";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly name: "_borrower";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "debt";
-        readonly type: "uint256";
-    }, {
-        readonly name: "coll";
-        readonly type: "uint256";
-    }, {
-        readonly name: "pendingDebtReward";
-        readonly type: "uint256";
-    }, {
-        readonly name: "pendingCollateralReward";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "getTroveStatus";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly name: "_borrower";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "getCurrentICR";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly name: "_borrower";
-        readonly type: "address";
-    }, {
-        readonly name: "_price";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "surplusBalances";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "claimCollateral";
-    readonly stateMutability: "nonpayable";
-    readonly inputs: readonly [{
-        readonly name: "_receiver";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [];
-}];
-/** River Oracle Fetcher module. */
-export declare const riverFetcher: {
-    getCalls: typeof getRiverCalls;
-    parse: typeof parseRiverResults;
-    getAbi: typeof getRiverAbi;
-};
-export {};
-//# sourceMappingURL=river.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"river.d.ts","sourceRoot":"","sources":["../../../../src/prices/oracle-prices/fetchers/river.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EAEb,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAA;AAIjB;;;;;;;;;;;GAWG;AAEH,UAAU,eAAe;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,8EAA8E;AAC9E,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,GACd,aAAa,CAAC,eAAe,CAAC,EAAE,CA4BlC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,YAAY,GACpB,gBAAgB,EAAE,CAqCpB;AAED,oDAAoD;AACpD,wBAAgB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAE1B;AAED,mCAAmC;AACnC,eAAO,MAAM,YAAY;;;;CAIxB,CAAA"}