/**
 * ERC-7756 Opacus QUIC Transport Registry
 *
 * USE CASE
 * --------
 * Any agent that communicates via HTTP/3 + QUIC (or eBPF kernel-bypass QUIC)
 * registers its transport endpoint on-chain so that peers — or smart contracts
 * — can discover the fastest path to it without a centralised directory.
 *
 * Designed for:
 *  • MEV bots         — 8–20 µs kernel-bypass path, 0-RTT reconnects
 *  • Arbitrage agents — discover peers by latency SLA on-chain
 *  • IoT edge nodes   — WebTransport datagram mode (browser-compatible)
 *  • Any agent using  — H3 Routing (ERC-7751) can cross-reference QUIC endpoints
 *
 * Transport modes
 * ---------------
 *  Standard (0)     — Regular QUIC/HTTP3
 *  KernelBypass (1) — eBPF + XDP zero-copy (sub-20 µs)
 *  Datagram (2)     — WebTransport datagrams (browser / edge workers)
 *
 * FEE MODEL
 * ---------
 * registerEndpoint() deducts 1% as a protocol bond fee to OPACUS_TREASURY.
 * The remaining 99% is locked and returned on deregisterEndpoint().
 */
import { ethers } from 'ethers';
export declare enum TransportMode {
    Standard = 0,
    KernelBypass = 1,
    Datagram = 2
}
export interface QuicEndpoint {
    agent: string;
    quicEndpoint: string;
    grpcEndpoint: string;
    mode: TransportMode;
    zeroRTT: boolean;
    kernelBypass: boolean;
    latencyBudgetUs: number;
    registeredAt: number;
    updatedAt: number;
}
export interface RegisterEndpointOptions {
    quicEndpoint: string;
    grpcEndpoint?: string;
    mode?: TransportMode;
    zeroRTT?: boolean;
    kernelBypass?: boolean;
    latencyBudgetUs?: number;
    /** ERC-20 token for registration bond. Omit or use ZeroAddress for ETH */
    token?: string;
    /** Gross amount (1% fee → treasury). Required if token is set. */
    grossAmount?: bigint;
}
export declare class QuicTransportClient {
    private contract;
    /**
     * @param address             Deployed ERC7756QuicTransport contract address
     * @param signerOrProvider    Signer for write ops, Provider for reads
     */
    constructor(address: string, signerOrProvider: ethers.Signer | ethers.Provider);
    /**
     * Register a QUIC transport endpoint on-chain.
     *
     * @example
     * // MEV bot — kernel-bypass, sub-20µs, ETH bond 0.01 ETH
     * await client.register({
     *   quicEndpoint:    'quic://mev-bot.example.com:4433',
     *   mode:            TransportMode.KernelBypass,
     *   kernelBypass:    true,
     *   zeroRTT:         true,
     *   latencyBudgetUs: 20,        // 20 µs SLA
     *   grossAmount:     ethers.parseEther('0.01'),
     * });
     */
    register(opts: RegisterEndpointOptions): Promise<ethers.ContractTransactionResponse>;
    /**
     * Update transport details without paying a fee.
     */
    update(opts: RegisterEndpointOptions): Promise<ethers.ContractTransactionResponse>;
    /**
     * Remove endpoint and reclaim 99% of bond.
     */
    deregister(): Promise<ethers.ContractTransactionResponse>;
    /**
     * Get the QUIC endpoint record for a specific agent wallet.
     */
    getEndpoint(agent: string): Promise<QuicEndpoint>;
    /**
     * Discover all agents with eBPF kernel-bypass enabled.
     * Ideal for MEV/arbitrage bots looking for the fastest peers.
     */
    getKernelBypassAgents(offset?: number, limit?: number): Promise<QuicEndpoint[]>;
    /**
     * Discover agents whose declared latency SLA is ≤ maxLatencyUs.
     *
     * @example
     * // Find sub-100µs agents
     * const fast = await client.getAgentsByLatency(100);
     */
    getAgentsByLatency(maxLatencyUs: number, offset?: number, limit?: number): Promise<QuicEndpoint[]>;
    totalAgents(): Promise<number>;
    private _mapEndpoint;
}
//# sourceMappingURL=ERC7756QuicClient.d.ts.map