import { type Address, type Hex } from "viem";
export type OracleInfo = {
    oracle: Address;
    name: string;
};
export type OracleDetailedInfo = {
    oracle: Address;
    name: string;
    oracleInfo: Hex;
};
export interface OraclePrice {
    queryFailure: boolean;
    queryFailureReason: Hex;
    amountIn: bigint;
    amountOutMid: bigint;
    amountOutBid: bigint;
    amountOutAsk: bigint;
    timestamp: number;
}
export type EulerRouterInfo = {
    governor: Address;
    fallbackOracle: Address;
    fallbackOracleInfo: OracleDetailedInfo;
    bases: Address[];
    quotes: Address[];
    resolvedAssets: Address[][];
    resolvedOracles: Address[];
    resolvedOraclesInfo: OracleDetailedInfo[];
};
export type CrossAdapterInfo = {
    base: Address;
    cross: Address;
    quote: Address;
    oracleBaseCross: Address;
    oracleCrossQuote: Address;
    oracleBaseCrossInfo: OracleDetailedInfo;
    oracleCrossQuoteInfo: OracleDetailedInfo;
};
export type PythOracleInfo = {
    pyth: Address;
    base: Address;
    quote: Address;
    feedId: Hex;
    maxStaleness: bigint;
    maxConfWidth: bigint;
};
export type PythFeed = {
    pythAddress: Address;
    feedId: Hex;
};
export type OracleAdapterEntry = {
    oracle: Address;
    name: string;
    base: Address;
    quote: Address;
    pythDetail?: PythOracleInfo;
    chainlinkDetail?: {
        oracle: Address;
    };
};
/** A leaf oracle contract call in an effective price route. */
export type OracleRouteAdapterStep = {
    kind: "adapter";
    oracle: Address;
    name: string;
    base: Address;
    quote: Address;
    pythDetail?: PythOracleInfo;
    chainlinkDetail?: {
        oracle: Address;
    };
};
/**
 * An ERC4626-style vault/share unwrapping hop in an effective price route.
 *
 * This is not a PriceOracle adapter. Consumers can still display and quote it
 * like the other route steps by calling `convertToAssets` on `vault`.
 */
export type OracleRouteVaultStep = {
    kind: "vault";
    oracle: Address;
    name: "ERC4626Vault";
    base: Address;
    quote: Address;
    vault: Address;
    asset: Address;
};
export type OracleRouteStep = OracleRouteAdapterStep | OracleRouteVaultStep;
/**
 * Where a route came from while resolving the root oracle info.
 *
 * configured: an explicit EulerRouter `base -> quote` entry.
 * fallback: the EulerRouter fallback oracle handled the requested pair.
 * direct: the root oracle info itself handled the requested pair.
 */
export type OracleRouteSource = "configured" | "fallback" | "direct";
/**
 * Effective ordered oracle route for one `base -> quote` pair.
 *
 * `steps` is the consumer surface: walk it in order to display or quote the
 * complete route. Use `getOracleRouteAdapters` or
 * `getOracleRouteResolvedVaults` when a caller needs the older projections.
 */
export type OracleRoute = {
    base: Address;
    quote: Address;
    steps: OracleRouteStep[];
    source: OracleRouteSource;
};
/**
 * A vault-address price route configured on EulerRouter.
 *
 * Some routers price an ERC4626/EVault share token by resolving it to the
 * vault's underlying asset path instead of using a leaf oracle adapter for the
 * vault address itself. `resolvedAssets` is that unwrap chain, not necessarily
 * the full price path to `quote`.
 *
 * vault: the base being priced, usually a collateral vault/share token address.
 * quote: the target denomination, i.e. the EVault unitOfAccount.
 * asset: the first underlying asset the router resolves the vault into.
 * resolvedAssets: the recursive ERC4626 unwrap chain from vault toward something the router can price against quote.
 */
export type OracleResolvedVault = {
    vault: Address;
    quote: Address;
    asset: Address;
    resolvedAssets: Address[];
};
export declare function getOracleAdapterSortKey(adapter: OracleAdapterEntry): string;
export declare function sortOracleAdapters(adapters: OracleAdapterEntry[]): OracleAdapterEntry[];
export declare function oracleRouteAdapterStepToAdapter(step: OracleRouteAdapterStep): OracleAdapterEntry;
export declare function getOracleRouteAdapters(routeOrSteps: OracleRoute | readonly OracleRouteStep[] | null | undefined): OracleAdapterEntry[];
export declare function getOracleRouteResolvedVaults(route: OracleRoute | null | undefined): OracleResolvedVault[];
export declare function sortOracleResolvedVaults(resolvedVaults: OracleResolvedVault[]): OracleResolvedVault[];
type OracleAdapterOptions = {
    base?: Address;
    quote?: Address;
    leafOnly?: boolean;
};
export declare const decodeEulerRouterInfo: (oracleInfo: Hex | string | Uint8Array) => EulerRouterInfo | null;
export declare const decodeCrossAdapterInfo: (oracleInfo: Hex | string | Uint8Array) => CrossAdapterInfo | null;
export declare const decodePythOracleInfo: (oracleInfo: Hex | string | Uint8Array) => PythOracleInfo | null;
export declare const collectPythFeedIds: (oracleInfo: OracleDetailedInfo | null | undefined, maxDepth?: number) => PythFeed[];
export declare const selectOracleRouteForPair: (routes: OracleRoute[] | undefined, base: Address, quote: Address) => OracleRoute | undefined;
export declare const decodeOracleRouteForPair: (oracleInfo: OracleDetailedInfo | null | undefined, base: Address, quote: Address, maxDepth?: number) => OracleRoute | undefined;
export declare const decodeOracleRoutes: (oracleInfo: OracleDetailedInfo | null | undefined, maxDepth?: number) => OracleRoute[];
export declare const decodeOracleInfo: (oracleInfo: OracleDetailedInfo | null | undefined, maxDepth?: number, options?: OracleAdapterOptions) => OracleAdapterEntry[];
export declare const decodeOracleResolvedVaults: (oracleInfo: OracleDetailedInfo | null | undefined, maxDepth?: number) => OracleResolvedVault[];
export declare const collectChainlinkOracles: (oracleInfo: OracleDetailedInfo | null | undefined, maxDepth?: number) => Address[];
/**
 * Walk an OracleDetailedInfo tree for the active price path of (base, quote)
 * and collect only the Pyth feed IDs actually used to price that pair.
 *
 * Unlike collectPythFeedIds (which returns every Pyth feed anywhere in the
 * tree) this avoids pulling Hermes updates for fallback routes that aren't
 * exercised during a given operation.
 */
export declare const collectPythFeedIdsForPair: (oracleInfo: OracleDetailedInfo | null | undefined, base: Address, quote: Address, maxDepth?: number) => PythFeed[];
/**
 * Route-aware Pyth feed selection over already-decoded OracleAdapterEntry[].
 * Uses selectResolvedVaultAdaptersForPair / selectLeafAdaptersForPair to pick
 * only the adapters on the active (base, quote) route, then extracts Pyth
 * feeds from that subset.
 */
export declare const collectPythFeedsForPair: (adapters: OracleAdapterEntry[], resolvedVaults: OracleResolvedVault[] | undefined, base: Address, quote: Address) => PythFeed[];
/**
 * Extract unique PythFeed entries from already-decoded oracle adapters.
 * Use this instead of collectPythFeedIds when you have OracleAdapterEntry[].
 */
export declare const collectPythFeedsFromAdapters: (adapters: OracleAdapterEntry[]) => PythFeed[];
/**
 * Extract unique PythFeed entries from route steps without requiring the
 * adapter projection to be stored on the vault.
 */
export declare const collectPythFeedsFromRouteSteps: (routeOrSteps: OracleRoute | readonly OracleRouteStep[] | null | undefined) => PythFeed[];
/**
 * Select adapters representing leaf pricing route(s) for a base->quote pair.
 * Falls back to direct pair matches when no leaf route is found.
 */
export declare const selectLeafAdaptersForPair: (adapters: OracleAdapterEntry[], base: Address, quote: Address, maxDepth?: number) => OracleAdapterEntry[];
export declare const selectResolvedVaultAdaptersForPair: (adapters: OracleAdapterEntry[], resolvedVaults: OracleResolvedVault[], base: Address, quote: Address) => OracleAdapterEntry[];
export {};
//# sourceMappingURL=oracle.d.ts.map