@btc-stamps/tx-builder/dist/providers/index.d.ts

Transaction builder for Bitcoin Stamps and SRC-20 tokens with advanced UTXO selection

import { E as ElectrumXConfig$1, a as ElectrumXServer, C as ConnectionPoolOptions, B as BaseProvider, b as ElectrumXProvider, c as ElectrumXConnectionPool } from '../electrumx-fee-estimator-Dmcstpen.js';
export { k as ElectrumXFeeEstimator, F as FeeEstimate, j as FeeEstimationOptions, n as createAggressiveFeeEstimator, m as createConservativeFeeEstimator, l as createElectrumXFeeEstimator, i as createElectrumXPool, d as createElectrumXProvider, f as createLocalDevelopmentProvider, e as createMultiEndpointProvider, h as createProviderFromEnvironment, g as createPublicProvider } from '../electrumx-fee-estimator-Dmcstpen.js';
import { Network } from 'bitcoinjs-lib';
import { P as ProviderOptions, U as UTXO, B as Balance, T as Transaction, A as AddressHistoryOptions, a as AddressHistory } from '../provider.interface-53Rg30ZJ.js';
import { a as FeeRate } from '../fee-normalizer-BGRDTCVR.js';
import 'node:buffer';

/**
 * Configuration Loader for tx-builder
 * Loads configuration with priority:
 * 1. Runtime options (passed to constructor)
 * 2. Environment variables
 * 3. Config file (.tx-builder.json or tx-builder.config.json)
 * 4. Default values
 */

declare class ConfigLoader {
    private static instance;
    /**
     * Load configuration with priority:
     * 1. Runtime options (passed to constructor)
     * 2. Environment variables (NEW: Uses centralized config)
     * 3. Config file (.tx-builder.json or tx-builder.config.json)
     * 4. Fallback defaults
     */
    static loadConfig(options?: Partial<ElectrumXConfig$1>): ElectrumXConfig$1;
    private load;
    private parseNetworkFromEnv;
    private loadLegacyEnvironment;
    private loadConfigFromEnvironment;
    private loadConfigFile;
    private fileExists;
    /**
     * Get configuration documentation
     */
    static getConfigDocumentation(): string;
}

/**
 * ElectrumX Pooled Provider
 * High-level provider that uses connection pooling for better performance and reliability
 */

interface ElectrumXPooledOptions extends ProviderOptions {
    servers?: ElectrumXServer[];
    poolOptions?: Partial<ConnectionPoolOptions>;
}
/**
 * ElectrumX Provider with built-in connection pooling and advanced features
 */
declare class ElectrumXPooledProvider extends BaseProvider {
    private pool;
    constructor(options: ElectrumXPooledOptions);
    /**
     * Get UTXOs for a given address
     */
    getUTXOs(address: string): Promise<UTXO[]>;
    /**
     * Get balance for a given address
     */
    getBalance(address: string): Promise<Balance>;
    /**
     * Get transaction by ID
     */
    getTransaction(txid: string): Promise<Transaction>;
    /**
     * Broadcast a signed transaction
     */
    broadcastTransaction(hexTx: string): Promise<string>;
    /**
     * Get current fee rate (sat/vB)
     */
    getFeeRate(priority?: 'low' | 'medium' | 'high'): Promise<number>;
    /**
     * Get current block height
     */
    getBlockHeight(): Promise<number>;
    /**
     * Get address transaction history
     */
    getAddressHistory(address: string, options?: AddressHistoryOptions): Promise<AddressHistory[]>;
    /**
     * Check if provider is connected (checks if any server is healthy)
     */
    isConnected(): Promise<boolean>;
    /**
     * Get ElectrumX servers from centralized configuration
     */
    private getServersFromConfig;
    /**
     * Get network name from Network object
     */
    private getNetworkName;
    /**
     * Map ElectrumX protocol to connection pool protocol
     */
    private mapProtocol;
    /**
     * Calculate weight from priority (lower priority = higher weight)
     */
    private calculateWeight;
    /**
     * Guess region from hostname (best effort)
     */
    private guessRegion;
    /**
     * Get connection pool statistics
     */
    getPoolStats(): {
        servers: Array<{
            server: string;
            healthy: boolean;
            activeConnections: number;
            totalRequests: number;
            successRate: number;
            averageResponseTime: number;
            consecutiveFailures: number;
            healthScore: number;
            circuitBreakerState: string;
            lastHeartbeat: Date | null;
            connectionsInUse: number;
        }>;
        totalConnections: number;
        totalActiveConnections: number;
        averageHealthScore: number;
        circuitBreakersOpen: number;
    };
    /**
     * Get detailed health information
     */
    getHealthInfo(): {
        healthy: boolean;
        healthyServers: number;
        totalServers: number;
        totalConnections: number;
        averageSuccessRate: number;
        servers: Array<{
            server: string;
            healthy: boolean;
            successRate: number;
            averageResponseTime: number;
            activeConnections: number;
        }>;
    };
    /**
     * Test connection to all configured servers
     */
    testAllConnections(): Promise<Array<{
        server: string;
        success: boolean;
        latency?: number;
        error?: string;
    }>>;
    /**
     * Get servers by region
     */
    getServersByRegion(): Record<string, ElectrumXServer[]>;
    /**
     * Update server configuration
     */
    updateServers(servers: ElectrumXServer[]): void;
    /**
     * Gracefully shutdown the provider
     */
    shutdown(): Promise<void>;
}
/**
 * Create ElectrumX pooled provider with sensible defaults
 */
declare function createElectrumXPooledProvider(network: Network, options?: Partial<ElectrumXPooledOptions>): ElectrumXPooledProvider;
/**
 * Create ElectrumX pooled provider with custom server configuration
 */
declare function createElectrumXPooledProviderWithServers(network: Network, servers: ElectrumXServer[], options?: Partial<ElectrumXPooledOptions>): ElectrumXPooledProvider;
/**
 * Create ElectrumX pooled provider optimized for specific use cases
 */
declare class ElectrumXPooledProviderBuilder {
    private network;
    private options;
    constructor(network: Network);
    /**
     * Set timeout values
     */
    withTimeouts(timeout: number, retries?: number, retryDelay?: number): this;
    /**
     * Configure for high-throughput applications
     */
    forHighThroughput(): this;
    /**
     * Configure for low-latency applications
     */
    forLowLatency(): this;
    /**
     * Configure for high reliability
     */
    forHighReliability(): this;
    /**
     * Add custom servers
     */
    withServers(servers: ElectrumXServer[]): this;
    /**
     * Filter servers by region from configured endpoints
     */
    withRegion(region: 'us' | 'eu' | 'asia' | 'global' | 'local'): this;
    /**
     * Guess region from hostname for builder (helper method)
     */
    private guessRegionForBuilder;
    /**
     * Get network name for builder
     */
    private getNetworkName;
    /**
     * Build the provider
     */
    build(): ElectrumXPooledProvider;
}

/**
 * ElectrumX Transaction Tracker
 * Advanced transaction broadcasting and status monitoring
 */

interface TransactionStatus {
    txid: string;
    status: 'pending' | 'broadcasted' | 'confirmed' | 'failed';
    confirmations: number;
    blockHeight?: number;
    timestamp: number;
    lastUpdated: number;
    error?: string;
    broadcastAttempts: number;
    maxBroadcastAttempts: number;
}
interface BroadcastOptions {
    maxRetries?: number;
    retryDelay?: number;
    maxRetryDelay?: number;
    trackStatus?: boolean;
    confirmationTarget?: number;
    timeoutMs?: number;
}
interface BroadcastResult {
    txid: string;
    success: boolean;
    error?: string;
    attempts: number;
    duration: number;
}
/**
 * Advanced transaction broadcasting with status tracking and retry logic
 */
declare class ElectrumXTransactionTracker {
    private provider;
    private defaultOptions;
    private trackedTransactions;
    private trackingInterval;
    private isTracking;
    constructor(provider: ElectrumXProvider | ElectrumXConnectionPool, defaultOptions?: Required<BroadcastOptions>);
    /**
     * Broadcast transaction with advanced retry logic and status tracking
     */
    broadcastTransaction(hexTx: string, options?: Partial<BroadcastOptions>): Promise<BroadcastResult>;
    /**
     * Get enhanced UTXO list with additional metadata
     */
    getEnhancedUTXOs(address: string): Promise<Array<{
        txid: string;
        vout: number;
        value: number;
        scriptPubKey: string;
        confirmations: number;
        height?: number;
        timestamp?: number;
        spendable: boolean;
        dust: boolean;
        mature: boolean;
    }>>;
    /**
     * Start tracking a transaction
     */
    private startTracking;
    /**
     * Update transaction status
     */
    private updateTransactionStatus;
    /**
     * Start periodic status checking for tracked transactions
     */
    private startPeriodicTracking;
    /**
     * Update status of all tracked transactions
     */
    private updateTrackedTransactions;
    /**
     * Stop periodic tracking
     */
    private stopPeriodicTracking;
    /**
     * Get status of a tracked transaction
     */
    getTransactionStatus(txid: string): TransactionStatus | null;
    /**
     * Get all tracked transactions
     */
    getAllTrackedTransactions(): TransactionStatus[];
    /**
     * Check if error is recoverable for retry
     */
    private isRecoverableError;
    /**
     * Validate transaction hex format
     */
    private validateTransactionHex;
    /**
     * Calculate transaction ID from hex (simplified)
     */
    private calculateTxid;
    /**
     * Execute with timeout
     */
    private executeWithTimeout;
    /**
     * Sleep for specified milliseconds
     */
    private sleep;
    /**
     * Clear all tracked transactions
     */
    clearTracked(): void;
    /**
     * Get transaction statistics
     */
    getStatistics(): {
        totalTracked: number;
        byStatus: Record<string, number>;
        averageBroadcastAttempts: number;
        averageConfirmationTime: number;
    };
    /**
     * Shutdown tracker and clean up
     */
    shutdown(): void;
}
/**
 * Create transaction tracker for ElectrumX provider
 */
declare function createElectrumXTracker(provider: ElectrumXProvider | ElectrumXConnectionPool, options?: Partial<BroadcastOptions>): ElectrumXTransactionTracker;

/**
 * ElectrumX Rate Limiter
 * Implements rate limiting, request throttling, and exponential backoff
 */
interface RateLimitConfig {
    maxRequestsPerSecond: number;
    maxRequestsPerMinute: number;
    maxConcurrentRequests: number;
    backoffMultiplier: number;
    maxBackoffDelay: number;
    baseBackoffDelay: number;
    resetWindowMs: number;
}
/**
 * Advanced rate limiter for ElectrumX requests with per-server tracking
 */
declare class ElectrumXRateLimiter {
    private config;
    private serverLimits;
    private requestHistory;
    private cleanupTimer;
    constructor(config?: Partial<RateLimitConfig>);
    /**
     * Check if request should be allowed and get delay if needed
     */
    checkRateLimit(serverKey: string, _method: string): {
        allowed: boolean;
        delayMs?: number;
        reason?: string;
    };
    /**
     * Record request start
     */
    recordRequestStart(serverKey: string, method: string): string;
    /**
     * Record request completion
     */
    recordRequestComplete(serverKey: string, method: string, success: boolean, duration: number): void;
    /**
     * Execute request with rate limiting
     */
    executeWithRateLimit<T>(serverKey: string, method: string, fn: () => Promise<T>): Promise<T>;
    /**
     * Get or create server limits
     */
    private getOrCreateServerLimits;
    /**
     * Update rate limit counters
     */
    private updateCounters;
    /**
     * Start cleanup timer
     */
    private startCleanup;
    /**
     * Clean up old request history
     */
    private cleanupHistory;
    /**
     * Sleep for specified milliseconds
     */
    private sleep;
    /**
     * Get rate limiting statistics
     */
    getStats(): {
        servers: Array<{
            serverKey: string;
            requestsThisSecond: number;
            requestsThisMinute: number;
            concurrentRequests: number;
            consecutiveFailures: number;
            backoffDelay: number;
            nextAllowedRequest: number;
        }>;
        recentRequests: {
            total: number;
            successful: number;
            failed: number;
            averageDuration: number;
            byMethod: Record<string, number>;
        };
    };
    /**
     * Reset rate limits for a server (use carefully)
     */
    resetServerLimits(serverKey: string): void;
    /**
     * Reset all rate limits (use carefully)
     */
    resetAllLimits(): void;
    /**
     * Update configuration
     */
    updateConfig(newConfig: Partial<RateLimitConfig>): void;
    /**
     * Shutdown rate limiter
     */
    shutdown(): void;
}
/**
 * Create rate limiter with sensible defaults
 */
declare function createElectrumXRateLimiter(config?: Partial<RateLimitConfig>): ElectrumXRateLimiter;
/**
 * Create conservative rate limiter (fewer requests, longer backoff)
 */
declare function createConservativeRateLimiter(): ElectrumXRateLimiter;
/**
 * Create aggressive rate limiter (more requests, shorter backoff)
 */
declare function createAggressiveRateLimiter(): ElectrumXRateLimiter;

/**
 * ElectrumX Response Cache
 * Intelligent caching system with TTL, LRU eviction, and invalidation strategies
 */

interface CacheEntry<T = any> {
    data: T;
    timestamp: number;
    ttl: number;
    accessCount: number;
    lastAccessed: number;
    size: number;
}
interface CacheConfig {
    maxMemoryMB: number;
    defaultTTL: number;
    utxoTTL: number;
    balanceTTL: number;
    transactionTTL: number;
    feeEstimateTTL: number;
    blockHeightTTL: number;
    cleanupInterval: number;
    compressionEnabled: boolean;
}
interface CacheStats {
    totalEntries: number;
    memoryUsageMB: number;
    hitRate: number;
    missRate: number;
    evictionCount: number;
    lastCleanup: number;
    entriesByType: Record<string, number>;
}
/**
 * Advanced caching system with LRU eviction and intelligent TTL
 */
declare class ElectrumXCache {
    private cache;
    private config;
    private accessOrder;
    private stats;
    private cleanupTimer;
    private memoryUsage;
    constructor(config?: Partial<CacheConfig>);
    /**
     * Get cached item
     */
    get<T>(key: string): T | null;
    /**
     * Set cached item
     */
    set<T>(key: string, data: T, ttl?: number, category?: 'utxo' | 'balance' | 'transaction' | 'fee' | 'block'): void;
    /**
     * Cache UTXO data with address-based invalidation
     */
    cacheUTXOs(address: string, utxos: UTXO[]): void;
    /**
     * Get cached UTXOs for address
     */
    getCachedUTXOs(address: string): UTXO[] | null;
    /**
     * Cache balance data
     */
    cacheBalance(address: string, balance: Balance): void;
    /**
     * Get cached balance
     */
    getCachedBalance(address: string): Balance | null;
    /**
     * Cache transaction data
     */
    cacheTransaction(txid: string, transaction: Transaction): void;
    /**
     * Get cached transaction
     */
    getCachedTransaction(txid: string): Transaction | null;
    /**
     * Cache fee estimate
     */
    cacheFeeEstimate(priority: string, feeRate: number): void;
    /**
     * Get cached fee estimate
     */
    getCachedFeeEstimate(priority: string): number | null;
    /**
     * Cache block height
     */
    cacheBlockHeight(height: number): void;
    /**
     * Get cached block height
     */
    getCachedBlockHeight(): number | null;
    /**
     * Invalidate cache entries by pattern
     */
    invalidatePattern(pattern: string): number;
    /**
     * Invalidate all UTXO caches for an address
     */
    invalidateAddress(address: string): void;
    /**
     * Invalidate all fee estimates
     */
    invalidateFeeEstimates(): void;
    /**
     * Batch set multiple items
     */
    setBatch<T>(items: Array<{
        key: string;
        data: T;
        ttl?: number;
        category?: string;
    }>): void;
    /**
     * Batch get multiple items
     */
    getBatch<T>(keys: string[]): Record<string, T | null>;
    /**
     * Get cache statistics
     */
    getStats(): CacheStats;
    /**
     * Clear all cache entries
     */
    clear(): void;
    /**
     * Get entries sorted by access frequency
     */
    getTopEntries(limit?: number): Array<{
        key: string;
        accessCount: number;
        age: number;
        size: number;
    }>;
    /**
     * Check if entry is expired
     */
    private isExpired;
    /**
     * Get TTL for category
     */
    private getTTLForCategory;
    /**
     * Estimate size of data in bytes
     */
    private estimateSize;
    /**
     * Update access order for LRU
     */
    private updateAccessOrder;
    /**
     * Remove from access order
     */
    private removeFromAccessOrder;
    /**
     * Enforce memory limit by evicting LRU entries
     */
    private enforceMemoryLimit;
    /**
     * Start cleanup timer
     */
    private startCleanupTimer;
    /**
     * Clean up expired entries
     */
    private cleanup;
    /**
     * Update cache configuration
     */
    updateConfig(newConfig: Partial<CacheConfig>): void;
    /**
     * Export cache data for analysis
     */
    export(): {
        config: CacheConfig;
        stats: CacheStats;
        entries: Array<{
            key: string;
            size: number;
            age: number;
            accessCount: number;
            ttl: number;
        }>;
    };
    /**
     * Import cache data (careful - this replaces current cache)
     */
    import(data: {
        entries: Array<{
            key: string;
            data: any;
            ttl: number;
        }>;
    }): void;
    /**
     * Shutdown cache
     */
    shutdown(): void;
}
/**
 * Create ElectrumX cache with sensible defaults
 */
declare function createElectrumXCache(config?: Partial<CacheConfig>): ElectrumXCache;
/**
 * Create memory-optimized cache (smaller memory footprint)
 */
declare function createMemoryOptimizedCache(): ElectrumXCache;
/**
 * Create performance-optimized cache (larger memory, longer TTL)
 */
declare function createPerformanceOptimizedCache(): ElectrumXCache;

/**
 * ElectrumX Performance Metrics
 * Comprehensive monitoring and metrics collection for ElectrumX operations
 */
interface MetricsSample {
    timestamp: number;
    value: number;
    metadata?: Record<string, any>;
}
interface RequestMetrics {
    method: string;
    serverKey: string;
    duration: number;
    success: boolean;
    error?: string;
    timestamp: number;
    cacheHit?: boolean;
    retryCount?: number;
}
interface PerformanceStats {
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    averageResponseTime: number;
    p95ResponseTime: number;
    p99ResponseTime: number;
    requestsPerSecond: number;
    errorRate: number;
    cacheHitRate: number;
    byMethod: Record<string, {
        count: number;
        successRate: number;
        averageTime: number;
    }>;
    byServer: Record<string, {
        count: number;
        successRate: number;
        averageTime: number;
        isHealthy: boolean;
    }>;
}
interface MetricsConfig {
    retentionPeriodMs: number;
    sampleIntervalMs: number;
    enableDetailed: boolean;
    maxSamples: number;
}
/**
 * Advanced metrics collection and analysis system
 */
declare class ElectrumXMetrics {
    private requestHistory;
    private responseTimes;
    private errorRates;
    private throughputSamples;
    private cacheHitRates;
    private config;
    private metricsTimer;
    private startTime;
    constructor(config?: Partial<MetricsConfig>);
    /**
     * Record a request metric
     */
    recordRequest(metrics: RequestMetrics): void;
    /**
     * Get current performance statistics
     */
    getStats(timeRangeMs?: number): PerformanceStats;
    /**
     * Get historical trend data
     */
    getTrendData(metric: 'responseTime' | 'errorRate' | 'throughput' | 'cacheHitRate', timeRangeMs?: number): MetricsSample[];
    /**
     * Get server health scores
     */
    getServerHealthScores(timeRangeMs?: number): Record<string, {
        score: number;
        factors: {
            successRate: number;
            averageResponseTime: number;
            availability: number;
        };
        recommendation: 'healthy' | 'warning' | 'unhealthy';
    }>;
    /**
     * Detect performance anomalies
     */
    detectAnomalies(sensitivityThreshold?: number): Array<{
        type: 'high_error_rate' | 'slow_response' | 'low_throughput' | 'server_degradation';
        severity: 'low' | 'medium' | 'high';
        message: string;
        timestamp: number;
        data: any;
    }>;
    /**
     * Get uptime information
     */
    getUptimeInfo(): {
        startTime: number;
        uptime: number;
        uptimeFormatted: string;
    };
    /**
     * Start periodic metrics collection
     */
    private startMetricsCollection;
    /**
     * Collect periodic metrics snapshots
     */
    private collectPeriodicMetrics;
    /**
     * Get empty stats structure
     */
    private getEmptyStats;
    /**
     * Reset all metrics
     */
    reset(): void;
    /**
     * Export metrics data
     */
    export(): {
        config: MetricsConfig;
        uptime: number;
        stats: PerformanceStats;
        requestHistory: RequestMetrics[];
        trends: {
            errorRates: MetricsSample[];
            throughputSamples: MetricsSample[];
            cacheHitRates: MetricsSample[];
        };
    };
    /**
     * Shutdown metrics collection
     */
    shutdown(): void;
}
/**
 * Create ElectrumX metrics collector
 */
declare function createElectrumXMetrics(config?: Partial<MetricsConfig>): ElectrumXMetrics;
/**
 * Create lightweight metrics collector (less detailed tracking)
 */
declare function createLightweightMetrics(): ElectrumXMetrics;
/**
 * Create comprehensive metrics collector (detailed tracking)
 */
declare function createComprehensiveMetrics(): ElectrumXMetrics;

/**
 * Mock ElectrumX Fee Rate Provider
 * Provides mock fee rates for testing and development
 * NOTE: This is a mock implementation - use ElectrumXFeeEstimator for production
 */

interface ElectrumXConfig {
    servers: Array<{
        host: string;
        port: number;
        ssl?: boolean;
        timeout?: number;
    }>;
    fallbackFeeRate?: number;
    cacheTimeout?: number;
    maxRetries?: number;
}
interface ElectrumXFeeResponse {
    1: number;
    3: number;
    6: number;
    12: number;
    25: number;
}
/**
 * Mock ElectrumX fee estimation provider for testing and development
 */
declare class MockElectrumXFeeProvider {
    private config;
    private cache;
    constructor(config: ElectrumXConfig);
    /**
     * Get fee rates from ElectrumX servers
     */
    getFeeRates(): Promise<FeeRate>;
    /**
     * Fetch fee rates from multiple ElectrumX servers
     */
    private fetchFeeRatesFromServers;
    /**
     * Query a single ElectrumX server for fee estimation
     */
    private queryElectrumXServer;
    /**
     * Generate realistic fee rates (mock implementation)
     * In production, this would be actual ElectrumX responses
     */
    private generateRealisticFeeRate;
    /**
     * Process ElectrumX fee response into standard format
     */
    private processFeeResponse;
    /**
     * Validate ElectrumX fee response
     */
    private isValidFeeResponse;
    /**
     * Get fallback fee rates when ElectrumX is unavailable
     */
    private getFallbackFeeRates;
    /**
     * Check if cached data is still valid
     */
    private isCacheValid;
    /**
     * Mock transaction getter for testing
     */
    getTransaction(txid: string): Promise<{
        txid: string;
        size: number;
        vsize: number;
        fee?: number;
    } | null>;
    /**
     * Clear cached fee data
     */
    clearCache(): void;
    /**
     * Get current cache stats
     */
    getCacheStats(): {
        size: number;
        entries: Array<{
            key: string;
            age: number;
        }>;
    };
    /**
     * Update server configuration
     */
    updateConfig(newConfig: Partial<ElectrumXConfig>): void;
    /**
     * Test connection to all configured servers
     */
    testConnections(): Promise<Array<{
        server: string;
        success: boolean;
        latency?: number;
        error?: string;
    }>>;
}
/**
 * Create mock ElectrumX fee provider with configuration from environment variables
 */
declare function createMockElectrumXFeeProvider(customServers?: ElectrumXConfig['servers'], network?: string): MockElectrumXFeeProvider;

export { BaseProvider, type BroadcastOptions, type BroadcastResult, type CacheConfig, type CacheEntry, type CacheStats, ConfigLoader, ConnectionPoolOptions, ElectrumXCache, type ElectrumXConfig, ElectrumXConnectionPool, type ElectrumXFeeResponse, ElectrumXMetrics, type ElectrumXPooledOptions, ElectrumXPooledProvider, ElectrumXPooledProviderBuilder, ElectrumXProvider, ElectrumXRateLimiter, ElectrumXServer, ElectrumXTransactionTracker, type MetricsConfig, type MetricsSample, MockElectrumXFeeProvider, type PerformanceStats, type RateLimitConfig, type RequestMetrics, type TransactionStatus, createAggressiveRateLimiter, createComprehensiveMetrics, createConservativeRateLimiter, createElectrumXCache, createElectrumXMetrics, createElectrumXPooledProvider, createElectrumXPooledProviderWithServers, createElectrumXRateLimiter, createElectrumXTracker, createLightweightMetrics, createMemoryOptimizedCache, createMockElectrumXFeeProvider, createPerformanceOptimizedCache };