/**
 * ZK-Powered Pricing Oracles
 * Proof-of-Correctness Price Feeds
 *
 * Oracle verisi → kanıt ile gelir (Pyth/Chainlink'in çözmediği problem)
 *
 * Protokol:
 * [Price Source]
 *    → (price, timestamp, ZK-Proof)
 *       → QUIC Broadcast
 *          → Agents
 *             → Verify locally
 *
 * Zero-Knowledge Proofs:
 * - Range proof: fiyatın manipüle edilmediği
 * - Consistency proof: TWAP uygunluğu
 * - Anti-tamper: oracle key consistency
 */
import { EventEmitter } from 'events';
export interface PriceFeed {
    pair: string;
    decimals: number;
    minUpdateInterval: number;
    maxDeviation: number;
    sources: string[];
}
export interface ZKPrice {
    pair: string;
    price: bigint;
    decimals: number;
    timestamp: number;
    confidence: number;
    proof: ZKProof;
    signature: Uint8Array;
    sourceCount: number;
}
export interface ZKProof {
    type: 'range' | 'consistency' | 'aggregate';
    commitment: Uint8Array;
    challenge: Uint8Array;
    response: Uint8Array;
    publicInputs: PublicInputs;
    verifierKey: Uint8Array;
}
export interface PublicInputs {
    priceHash: Uint8Array;
    timestampHash: Uint8Array;
    sourceCommitments: Uint8Array[];
    twapHash?: Uint8Array;
    rangeMin?: bigint;
    rangeMax?: bigint;
}
export interface TWAPData {
    pair: string;
    period: number;
    twap: bigint;
    samples: number;
    startTime: number;
    endTime: number;
}
/**
 * Pedersen Commitment (simplified)
 * Used for hiding price values while proving properties
 */
export declare class PedersenCommitment {
    private static G;
    private static H;
    /**
     * Create commitment: C = v*G + r*H
     */
    static commit(value: bigint, blinding: Uint8Array): Uint8Array;
    /**
     * Open commitment
     */
    static verify(commitment: Uint8Array, value: bigint, blinding: Uint8Array): boolean;
    private static bigintToBytes;
}
/**
 * Range Proof Generator
 * Proves that price is within valid range without revealing exact value
 */
export declare class RangeProofGenerator {
    /**
     * Generate range proof: min <= price <= max
     */
    static generate(price: bigint, min: bigint, max: bigint, blinding: Uint8Array): ZKProof;
    /**
     * Verify range proof
     */
    static verify(proof: ZKProof, min: bigint, max: bigint): boolean;
    private static bigintToBytes;
}
/**
 * Consistency Proof Generator
 * Proves TWAP consistency without revealing individual prices
 */
export declare class ConsistencyProofGenerator {
    /**
     * Generate TWAP consistency proof
     */
    static generate(prices: bigint[], timestamps: number[], twap: bigint): ZKProof;
    /**
     * Verify consistency proof
     */
    static verify(proof: ZKProof): boolean;
    private static computeTWAP;
    private static bigintToBytes;
}
/**
 * Aggregate Proof Generator
 * Proves correct aggregation from multiple sources
 */
export declare class AggregateProofGenerator {
    /**
     * Generate aggregate proof for multi-source price
     */
    static generate(sourcePrices: {
        source: string;
        price: bigint;
        weight: number;
    }[], aggregatedPrice: bigint): ZKProof;
    /**
     * Verify aggregate proof
     */
    static verify(proof: ZKProof): boolean;
    private static bigintToBytes;
}
/**
 * ZK Oracle Node
 * Generates and broadcasts ZK-proven price feeds
 */
export declare class ZKOracleNode extends EventEmitter {
    private config;
    private feeds;
    private prices;
    private updateInterval;
    private oracleKey;
    constructor(config?: {
        updateIntervalMs?: number;
        priceHistorySize?: number;
        defaultRangePercent?: number;
    });
    /**
     * Register a price feed
     */
    registerFeed(feed: PriceFeed): void;
    /**
     * Start oracle
     */
    start(): void;
    /**
     * Stop oracle
     */
    stop(): void;
    /**
     * Update all feeds
     */
    private updateAllFeeds;
    /**
     * Fetch price and generate proof
     */
    private fetchAndProve;
    /**
     * Fetch prices from multiple sources
     */
    private fetchFromSources;
    /**
     * Fetches live price from public APIs (Coinbase → CoinGecko fallback).
     * Returns price as bigint with 8 decimals (e.g. $2500 → 250000000000n).
     */
    private fetchLivePrice;
    private signPrice;
    private calculateConfidence;
    private addPrice;
    private getLastPrice;
    /**
     * Get current price with proof
     */
    getPrice(pair: string): ZKPrice | null;
    /**
     * Get TWAP with consistency proof
     */
    getTWAP(pair: string, periodMs: number): {
        twap: bigint;
        proof: ZKProof;
    } | null;
}
/**
 * ZK Oracle Verifier
 * Verifies ZK proofs locally
 */
export declare class ZKOracleVerifier {
    /**
     * Verify price proof
     */
    static verifyPrice(zkPrice: ZKPrice): boolean;
    /**
     * Verify TWAP proof
     */
    static verifyTWAP(twap: bigint, proof: ZKProof): boolean;
}
/**
 * High-level SDK API for ZK Oracles
 */
export declare class ZKOracleSDK {
    private node;
    /**
     * Initialize ZK Oracle
     */
    init(config?: {
        updateIntervalMs?: number;
    }): void;
    /**
     * Register price feed
     */
    registerFeed(feed: PriceFeed): void;
    /**
     * Start oracle
     */
    start(): void;
    /**
     * Stop oracle
     */
    stop(): void;
    /**
     * Get price with ZK proof
     */
    getPrice(pair: string): Promise<ZKPrice | null>;
    /**
     * Verify price locally
     */
    verify(zkPrice: ZKPrice): boolean;
    /**
     * Get TWAP with proof
     */
    getTWAP(pair: string, periodMs: number): {
        twap: bigint;
        proof: ZKProof;
    } | null;
    /**
     * Subscribe to price updates
     */
    onPriceUpdate(handler: (price: ZKPrice) => void): void;
}
export declare const zkOracle: ZKOracleSDK;
//# sourceMappingURL=zk-pricing.d.ts.map