openoracle-sdk-js/dist/api/oracle-api.d.ts

OpenOracle Node.js SDK - Intelligent Oracle Routing with Multiple LLM Providers

import { OracleClient } from '../core/client';
import { OracleConfig } from '../core/config';
import { OracleProvider, DataCategory } from '../types/enums';
import { OracleRoutingResponse, OracleDataPoint, AggregatedOracleData, ProviderCapabilities, ChainlinkPriceFeed, PythPriceFeed } from '../schemas/oracle-schemas';

export interface PriceQueryOptions {
    symbol: string;
    currency?: string;
    provider?: OracleProvider;
    maxAge?: number;
    includeFees?: boolean;
}
export interface DataQueryOptions {
    query: string;
    category: DataCategory;
    providers?: OracleProvider[];
    maxProviders?: number;
    consensusRequired?: boolean;
    timeoutMs?: number;
}
export declare class OracleAPI {
    private readonly client;
    private readonly config;
    constructor(client: OracleClient, config: OracleConfig);
    /**
     * Query price data from oracle providers
     */
    getPrice(options: PriceQueryOptions): Promise<OracleDataPoint[]>;
    /**
     * Query general data from oracle providers
     */
    queryData(options: DataQueryOptions): Promise<OracleRoutingResponse>;
    /**
     * Get Chainlink price feeds
     */
    getChainlinkFeed(feedId: string, chainId?: number): Promise<ChainlinkPriceFeed>;
    /**
     * Get Pyth price feeds
     */
    getPythFeed(priceId: string): Promise<PythPriceFeed>;
    /**
     * List available Chainlink price feeds
     */
    listChainlinkFeeds(chainId?: number): Promise<string[]>;
    /**
     * List available Pyth price feeds
     */
    listPythFeeds(): Promise<string[]>;
    /**
     * Get provider capabilities
     */
    getProviderCapabilities(provider: OracleProvider): Promise<ProviderCapabilities>;
    /**
     * List all available providers
     */
    listProviders(): Promise<OracleProvider[]>;
    /**
     * Health check for specific provider
     */
    checkProviderHealth(provider: OracleProvider): Promise<boolean>;
    /**
     * Aggregate data from multiple providers
     */
    aggregateData(query: string, category: DataCategory, providers: OracleProvider[]): Promise<AggregatedOracleData>;
    /**
     * Subscribe to real-time price updates
     */
    subscribeToPriceUpdates(symbol: string, callback: (data: OracleDataPoint) => void, options?: {
        provider?: OracleProvider;
        interval?: number;
        currency?: string;
    }): EventSource;
    /**
     * Subscribe to general data updates
     */
    subscribeToDataUpdates(query: string, category: DataCategory, callback: (data: OracleRoutingResponse) => void, options?: {
        providers?: OracleProvider[];
        interval?: number;
    }): EventSource;
    /**
     * Create a custom oracle feed
     */
    createCustomFeed(feedConfig: {
        name: string;
        description: string;
        category: DataCategory;
        sources: Array<{
            provider: OracleProvider;
            weight: number;
            config: Record<string, any>;
        }>;
        updateFrequency: string;
        aggregationMethod: 'average' | 'median' | 'weighted' | 'consensus';
    }): Promise<{
        feedId: string;
    }>;
    /**
     * Get custom feed data
     */
    getCustomFeedData(feedId: string): Promise<OracleDataPoint[]>;
    /**
     * List user's custom feeds
     */
    listCustomFeeds(): Promise<Array<{
        feedId: string;
        name: string;
        category: DataCategory;
        status: 'active' | 'inactive' | 'error';
        lastUpdate: string;
    }>>;
    /**
     * Delete a custom feed
     */
    deleteCustomFeed(feedId: string): Promise<boolean>;
    /**
     * Batch query multiple data points
     */
    batchQuery(queries: Array<{
        query: string;
        category: DataCategory;
        provider?: OracleProvider;
    }>): Promise<OracleRoutingResponse[]>;
    /**
     * Get historical data
     */
    getHistoricalData(query: string, category: DataCategory, timeRange: {
        from: Date;
        to: Date;
        interval?: '1m' | '5m' | '15m' | '1h' | '1d';
    }, provider?: OracleProvider): Promise<OracleDataPoint[]>;
    /**
     * Get provider statistics
     */
    getProviderStats(provider: OracleProvider, timeRange?: {
        from: Date;
        to: Date;
    }): Promise<{
        requestCount: number;
        successRate: number;
        averageResponseTime: number;
        uptime: number;
        costPerQuery: number;
    }>;
}