@objectivelabs/oracle-sdk/dist/index.d.ts

JavaScript utilities for Euler price oracles

import { Address, PublicClient, Hex, Abi, BlockNumber, BlockTag } from 'viem';

declare const RDD_URL = "https://reference-data-directory.vercel.app";
declare const chainIdToRddSlug: Record<number, string>;

type ChainlinkFeed = {
    chainId: number;
    address: Address;
    accessController: Address;
    aggregator: Address;
    decimals: number;
    description: string;
    owner: Address;
    version: bigint;
};
type ChainlinkFeedMetadata = {
    compareOffchain: string;
    contractAddress: string;
    contractType: string;
    contractVersion: number;
    decimalPlaces: number | null;
    ens: string;
    formatDecimalPlaces: number | null;
    healthPrice: string;
    heartbeat: number;
    history: null;
    multiply: string;
    name: string;
    pair: [string, string];
    path: string;
    proxyAddress: string;
    threshold: number;
    valuePrefix: string;
    assetName: string;
    feedCategory: string;
    feedType: string;
    decimals: number;
    docs: {
        assetClass?: string;
        assetSubClass?: string;
        assetName?: string;
        baseAsset?: string;
        baseAssetClic?: string;
        blockchainName?: string;
        clicProductName?: string;
        deliveryChannelCode?: string;
        feedCategory?: string;
        feedType?: string;
        marketHours?: string;
        productSubType?: string;
        productType?: string;
        productTypeCode?: string;
        quoteAsset?: string;
        quoteAssetClic?: string;
        underlyingAsset?: string;
        underlyingAssetClic?: string;
    };
};
type ChainlinkMetadata = ChainlinkFeedMetadata[];

declare function fetchChainlinkMetadata(chainId: number): Promise<ChainlinkMetadata>;

declare function fetchChainlinkMetadataByRddUrl(rddUrl: string): Promise<ChainlinkMetadata>;

type Params$d = {
    publicClient: PublicClient;
    addresses: Address[];
};
declare function indexChainlinkFeeds({ publicClient, addresses, }: Params$d): Promise<ChainlinkFeed[]>;

type ChronicleFeed = {
    chainId: number;
    address: Address;
    authed: Address[];
    bar: number;
    challengeReward: bigint;
    decimals: number;
    feedRegistrationMessage: string;
    feeds: Address[];
    maxChallengeReward: bigint;
    opChallengePeriod: number;
    opFeedId: number;
    tolled: Address[];
    wat: string;
};

type Params$c = {
    publicClient: PublicClient;
    addresses: Address[];
};
declare function indexChronicleFeeds({ publicClient, addresses, }: Params$c): Promise<ChronicleFeed[]>;

declare const EORACLE_CONFIGS_BASE_URL = "https://raw.githubusercontent.com/Eoracle/target-contracts/refs/heads/develop/script/config/";

type EOracleMetadata = {
    symbol: string;
    feedAddress: Address;
    deviationPercentage: number;
    heartbeat: number;
}[];
type EOracleFeed = {
    chainId: number;
    address: Address;
    decimals: number;
    description: string;
    feedId: number;
    version: bigint;
};

declare function fetchEOracleMetadata(chainId: number): Promise<EOracleMetadata>;

type Params$b = {
    publicClient: PublicClient;
    addresses: Address[];
};
declare function indexEOracleFeeds({ publicClient, addresses, }: Params$b): Promise<EOracleFeed[]>;

declare const deploymentArtifacts: Record<string, any>;

declare const verificationArtifacts: Record<string, any>;

type Params$a = {
    publicClient: PublicClient;
    factoryAddress: Address;
};
declare function fetchDeployedRouters({ publicClient, factoryAddress, }: Params$a): Promise<Address[]>;

type ChainlinkOracle = {
    address: Address;
    chainId: number;
    name: 'ChainlinkOracle';
    base: Address;
    quote: Address;
    feed: Address;
    maxStaleness: bigint;
};
type ChainlinkInfrequentOracle = {
    address: Address;
    chainId: number;
    name: 'ChainlinkInfrequentOracle';
    base: Address;
    quote: Address;
    feed: Address;
    maxStaleness: bigint;
};
type ChronicleOracle = {
    address: Address;
    chainId: number;
    name: 'ChronicleOracle';
    base: Address;
    quote: Address;
    feed: Address;
    maxStaleness: bigint;
};
type CurveEMAOracle = {
    address: Address;
    chainId: number;
    name: 'CurveEMAOracle';
    base: Address;
    quote: Address;
    pool: Address;
    priceOracleIndex: bigint;
};
type LidoOracle = {
    address: Address;
    chainId: number;
    name: 'LidoOracle';
    WSTETH: Address;
    STETH: Address;
};
type LidoFundamentalOracle = {
    address: Address;
    chainId: number;
    name: 'LidoFundamentalOracle';
    WSTETH: Address;
    STETH: Address;
    WETH: Address;
};
type PythOracle = {
    address: Address;
    chainId: number;
    name: 'PythOracle';
    base: Address;
    quote: Address;
    pyth: Address;
    feedId: Hex;
    maxStaleness: bigint;
    maxConfWidth: bigint;
};
type RedstoneCoreOracle = {
    address: Address;
    chainId: number;
    name: 'RedstoneCoreOracle';
    base: Address;
    quote: Address;
    feedId: Hex;
    maxStaleness: bigint;
    feedDecimals: number;
};
type CrossAdapter = {
    address: Address;
    chainId: number;
    name: 'CrossAdapter';
    base: Address;
    quote: Address;
    cross: Address;
    oracleBaseCross: Address;
    oracleCrossQuote: Address;
};
type FixedRateOracle = {
    address: Address;
    chainId: number;
    name: 'FixedRateOracle';
    base: Address;
    quote: Address;
    rate: bigint;
};
type RateProviderOracle = {
    address: Address;
    chainId: number;
    name: 'RateProviderOracle';
    base: Address;
    quote: Address;
    rateProvider: Address;
};
type PendleOracle = {
    address: Address;
    chainId: number;
    name: 'PendleOracle';
    base: Address;
    quote: Address;
    pendleMarket: Address;
    twapWindow: number;
};
type PendleUniversalOracle = {
    address: Address;
    chainId: number;
    name: 'PendleUniversalOracle';
    base: Address;
    quote: Address;
    pendleMarket: Address;
    twapWindow: number;
};
type SwaapSafeguardOracle = {
    address: Address;
    chainId: number;
    name: 'SwaapSafeguardOracle';
    safeguardPool: Address;
    quote: Address;
    poolId: Hex;
};
type UniswapV3Oracle = {
    address: Address;
    chainId: number;
    name: 'UniswapV3Oracle';
    tokenA: Address;
    tokenB: Address;
    pool: Address;
    fee: number;
    twapWindow: number;
};
type IdleTranchesOracle = {
    address: Address;
    chainId: number;
    name: 'IdleTranchesOracle';
    cdo: Address;
    tranche: Address;
    underlying: Address;
};
type Adapter = ChainlinkOracle | ChainlinkInfrequentOracle | ChronicleOracle | CurveEMAOracle | LidoOracle | LidoFundamentalOracle | PythOracle | RedstoneCoreOracle | CrossAdapter | FixedRateOracle | RateProviderOracle | PendleOracle | PendleUniversalOracle | SwaapSafeguardOracle | IdleTranchesOracle | UniswapV3Oracle;
type Asset = {
    chainId: number;
    address: Address;
    name: string;
    symbol: string;
    decimals: number;
};
type RegistryEntry = {
    addedAt: bigint;
    revokedAt: bigint;
};

declare function getAssetAddresses(adapter: Adapter): Address[];

declare function getConstructorArgs(adapter: Adapter): readonly unknown[];

type DeployArgs = {
    abi: Abi;
    args: readonly unknown[];
    bytecode: Hex;
};
declare function getDeploymentArgs(adapter: Adapter): DeployArgs;

declare function getEffectiveBaseAndQuote(adapter: Adapter): [Address, Address];

type Params$9 = {
    adapterAddresses: Address[];
    publicClient: PublicClient;
};
declare function indexAdapters({ adapterAddresses, publicClient, }: Params$9): Promise<(Adapter | null)[]>;

type Params$8 = {
    publicClient: PublicClient;
    addresses: Address[];
    fallbacks?: Asset[];
};
declare function indexAssets({ publicClient, addresses, fallbacks, }: Params$8): Promise<Asset[]>;

type Params$7 = {
    publicClient: PublicClient;
    routerAddresses: Address[];
    fromBlock: BlockNumber | BlockTag | undefined;
    toBlock: BlockNumber | BlockTag | undefined;
};
declare function indexRouterHistoricalAdapters({ publicClient, routerAddresses, fromBlock, toBlock, }: Params$7): Promise<Address[]>;

type Params$6 = {
    publicClient: PublicClient;
    snapshotRegistry: Address;
    fromBlock: BlockNumber | BlockTag | undefined;
    toBlock: BlockNumber | BlockTag | undefined;
};
declare function indexRegistry({ publicClient, snapshotRegistry, fromBlock, toBlock, }: Params$6): Promise<Record<Address, RegistryEntry>>;

type IdleCDO = {
    chainId: number;
    address: Address;
    owner: Address;
    guardian: Address;
    token: Address;
    paused: boolean;
};
type IdleTranche = {
    chainId: number;
    address: Address;
    name: string;
    symbol: string;
    decimals: number;
    minter: Address;
};

type Params$5 = {
    publicClient: PublicClient;
    addresses: Address[];
};
declare function indexIdleCDOs({ publicClient, addresses }: Params$5): Promise<IdleCDO[]>;

type Params$4 = {
    publicClient: PublicClient;
    addresses: Address[];
};
declare function indexIdleTranches({ publicClient, addresses, }: Params$4): Promise<IdleTranche[]>;

type MevLinearDiscountFeed = {
    chainId: number;
    address: Address;
    PT: Address;
    baseDiscountPerYear: bigint;
    decimals: number;
    description: string;
    maturity: bigint;
};

type Params$3 = {
    publicClient: PublicClient;
    addresses: Address[];
};
declare function indexMevLinearDiscountFeeds({ publicClient, addresses, }: Params$3): Promise<MevLinearDiscountFeed[]>;

declare const chainIdToPendleOracle: Record<number, Address>;

type PendleMarket = {
    chainId: number;
    address: Address;
    decimals: number;
    expiry: bigint;
    name: string;
    symbol: string;
    factory: Address;
    totalSupply: bigint;
    totalActiveSupply: bigint;
};
type PendleMetadata = {
    chainId: number;
    pt: Address;
    market: Address;
    underlyingAsset: Address;
    expiry: number;
    symbol: string;
}[];

declare function fetchPendleMetadata(chainId: number): Promise<PendleMetadata>;

type Params$2 = {
    publicClient: PublicClient;
    addresses: Address[];
};
declare function indexPendleMarkets({ publicClient, addresses, }: Params$2): Promise<PendleMarket[]>;

declare const chainIdToPythProxy: Record<number, Address>;

declare const DEFAULT_HERMES_URL = "https://hermes.pyth.network";

interface PythPriceFeed {
    id: string;
    attributes: {
        asset_type: string;
        base: string;
        description: string;
        display_symbol: string;
        generic_symbol: string;
        quote_currency: string;
        schedule: string;
        symbol: string;
    };
}
type PythMetadata = PythPriceFeed[];

declare function fetchPythMetadata(hermesUrl?: string): Promise<PythMetadata>;

declare function fetchPythUpdateData(feedIds: string[], hermesUrl?: string): Promise<Hex>;

type RedStoneRelayerManifestSlugs = {
    multi?: string;
    standalone: string[];
};
declare const chainIdToRedStoneRelayerManifestSlugs: Record<number, RedStoneRelayerManifestSlugs>;

declare const REDSTONE_MANIFESTS_BASE_URL = "https://raw.githubusercontent.com/redstone-finance/redstone-oracles-monorepo/refs/heads/main/packages/relayer-remote-config/main/";

type Chain = {
    name: string;
    id: number;
};
type UpdateTriggers = {
    deviationPercentage?: number;
    timeSinceLastUpdateInMilliseconds?: number;
    cron?: string[];
};
type RedStoneRelayerBase = {
    chain: Chain;
    updateTriggers: UpdateTriggers;
    adapterContract: Address;
    dataServiceId: string;
};
type RedStoneRelayerManifest = RedStoneRelayerBase & {
    priceFeeds: {
        [key: string]: Address;
    };
};
type RedStoneRelayerMultiFeedManifest = RedStoneRelayerBase & {
    adapterContractType: 'multi-feed';
    priceFeeds: {
        [key: string]: {
            priceFeedAddress: Address;
            updateTriggersOverrides?: UpdateTriggers;
        };
    };
};
type RedStoneMetadata = {
    symbol: string;
    priceFeedAddress: Address;
    deviationPercentage?: number;
    heartbeat?: number;
}[];
type RedStoneFeed = {
    chainId: number;
    address: Address;
    aggregator: Address;
    decimals: number;
    description: string;
    version: bigint;
    dataFeedId: Hex;
    priceFeedAdapter: Address;
};

declare function fetchRedStoneMetadata(chainId: number): Promise<RedStoneMetadata>;

type Params$1 = {
    publicClient: PublicClient;
    addresses: Address[];
};
declare function indexRedStoneFeeds({ publicClient, addresses, }: Params$1): Promise<RedStoneFeed[]>;

type SwaapSafeguardPool = {
    address: Address;
    chainId: number;
    name: string;
    symbol: string;
    decimals: number;
    poolId: Hex;
    owner: Address;
    signer: Address;
    authorizer: Address;
    protocolFeesCollector: Address;
    paused: boolean;
    recoveryMode: boolean;
    allowlistEnabled: boolean;
};

type Params = {
    publicClient: PublicClient;
    addresses: Address[];
};
declare function indexSwaapPools({ publicClient, addresses, }: Params): Promise<SwaapSafeguardPool[]>;

export { type Adapter, type Asset, type ChainlinkFeed, type ChainlinkFeedMetadata, type ChainlinkInfrequentOracle, type ChainlinkMetadata, type ChainlinkOracle, type ChronicleFeed, type ChronicleOracle, type CrossAdapter, type CurveEMAOracle, DEFAULT_HERMES_URL, EORACLE_CONFIGS_BASE_URL, type EOracleFeed, type EOracleMetadata, type FixedRateOracle, type IdleCDO, type IdleTranche, type IdleTranchesOracle, type LidoFundamentalOracle, type LidoOracle, type MevLinearDiscountFeed, type PendleMarket, type PendleMetadata, type PendleOracle, type PendleUniversalOracle, type PythMetadata, type PythOracle, type PythPriceFeed, RDD_URL, REDSTONE_MANIFESTS_BASE_URL, type RateProviderOracle, type RedStoneFeed, type RedStoneMetadata, type RedStoneRelayerManifest, type RedStoneRelayerMultiFeedManifest, type RedstoneCoreOracle, type RegistryEntry, type SwaapSafeguardOracle, type SwaapSafeguardPool, type UniswapV3Oracle, chainIdToPendleOracle, chainIdToPythProxy, chainIdToRddSlug, chainIdToRedStoneRelayerManifestSlugs, deploymentArtifacts, fetchChainlinkMetadata, fetchChainlinkMetadataByRddUrl, fetchDeployedRouters, fetchEOracleMetadata, fetchPendleMetadata, fetchPythMetadata, fetchPythUpdateData, fetchRedStoneMetadata, getAssetAddresses, getConstructorArgs, getDeploymentArgs, getEffectiveBaseAndQuote, indexAdapters, indexAssets, indexChainlinkFeeds, indexChronicleFeeds, indexEOracleFeeds, indexIdleCDOs, indexIdleTranches, indexMevLinearDiscountFeeds, indexPendleMarkets, indexRedStoneFeeds, indexRegistry, indexRouterHistoricalAdapters, indexSwaapPools, verificationArtifacts };