Basic Oracle Implementation

class DataSourceManager {
  constructor() {
    this.sources = {
      coingecko: {
        url: 'https://api.coingecko.com/api/v3/simple/price',
        params: { ids: 'ripple', vs_currencies: 'usd' },
        weight: 0.4,
        timeout: 5000,
        retryCount: 0,
        circuitOpen: false
      },
      coinmarketcap: {
        url: 'https://pro-api.coinmarketcap.com/v1/cryptocurrency/quotes/latest',
        params: { symbol: 'XRP' },
        weight: 0.35,
        timeout: 5000,
        retryCount: 0,
        circuitOpen: false
      },
      binance: {
        url: 'https://api.binance.com/api/v3/ticker/price',
        params: { symbol: 'XRPUSDT' },
        weight: 0.25,
        timeout: 3000,
        retryCount: 0,
        circuitOpen: false
      }
    };
    this.maxRetries = 5;
    this.circuitBreakerThreshold = 5;
  }

  async fetchPrice(sourceName) {
    const source = this.sources[sourceName];
    
    if (source.circuitOpen) {
      // Test circuit breaker every 60 seconds
      if (Date.now() - source.lastFailure < 60000) {
        throw new Error(`Circuit breaker open for ${sourceName}`);
      }
      source.circuitOpen = false;
      source.retryCount = 0;
    }

    try {
      const response = await this.makeRequest(source);
      source.retryCount = 0; // Reset on success
      return this.parseResponse(sourceName, response);
    } catch (error) {
      source.retryCount++;
      
      if (source.retryCount >= this.circuitBreakerThreshold) {
        source.circuitOpen = true;
        source.lastFailure = Date.now();
        console.warn(`Circuit breaker triggered for ${sourceName}`);
      }
      
      throw error;
    }
  }

  async aggregatePrices() {
    const promises = Object.keys(this.sources).map(async (sourceName) => {
      try {
        const price = await this.fetchPrice(sourceName);
        return {
          source: sourceName,
          price: price,
          weight: this.sources[sourceName].weight,
          timestamp: Date.now()
        };
      } catch (error) {
        console.warn(`Failed to fetch from ${sourceName}:`, error.message);
        return null;
      }
    });

    const results = (await Promise.all(promises)).filter(r => r !== null);
    
    if (results.length === 0) {
      throw new Error('All data sources failed');
    }

    // Calculate weighted average
    const totalWeight = results.reduce((sum, r) => sum + r.weight, 0);
    const weightedSum = results.reduce((sum, r) => sum + (r.price * r.weight), 0);
    
    return {
      price: weightedSum / totalWeight,
      sources: results.length,
      confidence: Math.min(totalWeight, 1.0), // Max confidence when all sources available
      timestamp: Date.now()
    };
  }
}

class XRPLOracle {
  constructor(seed, testnet = true) {
    this.wallet = xrpl.Wallet.fromSeed(seed);
    this.client = new xrpl.Client(testnet ? 'wss://s.altnet.rippletest.net:51233' : 'wss://xrplcluster.com');
    this.lastPublishedPrice = null;
    this.updateThreshold = 0.005; // 0.5% minimum change
    this.sequence = null;
  }

  async connect() {
    await this.client.connect();
    
    // Get current account sequence for transaction ordering
    const accountInfo = await this.client.request({
      command: 'account_info',
      account: this.wallet.address
    });
    
    this.sequence = accountInfo.result.account_data.Sequence;
    console.log(`Connected as ${this.wallet.address}, sequence: ${this.sequence}`);
  }

  encodePrice(priceData) {
    // Encode price data in Domain field (max 256 bytes as hex)
    const data = {
      price: Math.round(priceData.price * 1000000), // Store as micro-dollars for precision
      timestamp: priceData.timestamp,
      confidence: Math.round(priceData.confidence * 100),
      sources: priceData.sources
    };
    
    const jsonString = JSON.stringify(data);
    return Buffer.from(jsonString).toString('hex').toUpperCase();
  }

  shouldUpdate(newPrice) {
    if (!this.lastPublishedPrice) return true;
    
    const priceDiff = Math.abs(newPrice.price - this.lastPublishedPrice.price);
    const percentChange = priceDiff / this.lastPublishedPrice.price;
    
    return percentChange >= this.updateThreshold;
  }

  async publishPrice(priceData) {
    if (!this.shouldUpdate(priceData)) {
      console.log(`Price change ${(Math.abs(priceData.price - this.lastPublishedPrice.price) / this.lastPublishedPrice.price * 100).toFixed(3)}% below threshold`);
      return null;
    }

    const transaction = {
      TransactionType: 'AccountSet',
      Account: this.wallet.address,
      Domain: this.encodePrice(priceData),
      Sequence: this.sequence,
      Fee: '12', // Slightly above minimum for reliable processing
      Memos: [{
        Memo: {
          MemoType: Buffer.from('oracle-update').toString('hex').toUpperCase(),
          MemoData: Buffer.from(JSON.stringify({
            asset: 'XRP',
            price: priceData.price,
            timestamp: priceData.timestamp,
            confidence: priceData.confidence,
            sources: priceData.sources,
            version: '1.0'
          })).toString('hex').toUpperCase()
        }
      }]
    };

    try {
      const prepared = await this.client.autofill(transaction);
      const signed = this.wallet.sign(prepared);
      const result = await this.client.submitAndWait(signed.tx_blob);
      
      if (result.result.meta.TransactionResult === 'tesSUCCESS') {
        this.lastPublishedPrice = priceData;
        this.sequence++;
        console.log(`Published price $${priceData.price.toFixed(4)} (tx: ${signed.hash})`);
        return signed.hash;
      } else {
        throw new Error(`Transaction failed: ${result.result.meta.TransactionResult}`);
      }
    } catch (error) {
      console.error('Failed to publish price:', error);
      throw error;
    }
  }

  async publishHeartbeat() {
    // Send heartbeat even without price changes
    const heartbeatTx = {
      TransactionType: 'Payment',
      Account: this.wallet.address,
      Destination: this.wallet.address, // Self-payment
      Amount: '1', // 1 drop (minimum)
      Sequence: this.sequence,
      Fee: '12',
      Memos: [{
        Memo: {
          MemoType: Buffer.from('oracle-heartbeat').toString('hex').toUpperCase(),
          MemoData: Buffer.from(JSON.stringify({
            timestamp: Date.now(),
            status: 'operational',
            lastUpdate: this.lastPublishedPrice?.timestamp || null
          })).toString('hex').toUpperCase()
        }
      }]
    };

    try {
      const prepared = await this.client.autofill(heartbeatTx);
      const signed = this.wallet.sign(prepared);
      const result = await this.client.submitAndWait(signed.tx_blob);
      
      if (result.result.meta.TransactionResult === 'tesSUCCESS') {
        this.sequence++;
        console.log(`Heartbeat sent (tx: ${signed.hash})`);
        return signed.hash;
      }
    } catch (error) {
      console.error('Heartbeat failed:', error);
    }
  }
}

class OracleErrorHandler {
  constructor(oracle) {
    this.oracle = oracle;
    this.errorCounts = new Map();
    this.lastErrors = new Map();
    this.alertThresholds = {
      consecutive_failures: 5,
      error_rate: 0.1, // 10% over 1 hour
      balance_warning: 10, // XRP
      stale_data_warning: 300000 // 5 minutes
    };
  }

  async handleDataSourceError(sourceName, error) {
    const errorKey = `${sourceName}_${error.constructor.name}`;
    const count = this.errorCounts.get(errorKey) || 0;
    this.errorCounts.set(errorKey, count + 1);
    this.lastErrors.set(errorKey, { error, timestamp: Date.now() });

    // Rate limit specific error types
    if (error.message.includes('rate limit')) {
      await this.backoffDelay(count);
    }

    // Alert on persistent failures
    if (count >= this.alertThresholds.consecutive_failures) {
      await this.sendAlert('data_source_failure', {
        source: sourceName,
        error: error.message,
        count: count
      });
    }

    console.warn(`Data source error (${sourceName}): ${error.message} [${count} times]`);
  }

  async handleTransactionError(error, transaction) {
    console.error('Transaction error:', error);

    // Handle specific XRPL error codes
    if (error.message.includes('tecUNFUNDED_PAYMENT')) {
      await this.handleInsufficientBalance();
    } else if (error.message.includes('tefPAST_SEQ')) {
      await this.repairSequence();
    } else if (error.message.includes('terQUEUED')) {
      // Transaction queued due to network congestion
      await this.escalateFee(transaction);
    }

    // Log for debugging
    this.logTransactionFailure(error, transaction);
  }

  async handleInsufficientBalance() {
    const accountInfo = await this.oracle.client.request({
      command: 'account_info',
      account: this.oracle.wallet.address
    });

    const balance = Number(accountInfo.result.account_data.Balance) / 1000000;
    
    await this.sendAlert('low_balance', {
      address: this.oracle.wallet.address,
      balance: balance,
      threshold: this.alertThresholds.balance_warning
    });

    console.error(`Insufficient balance: ${balance} XRP`);
  }

  async repairSequence() {
    try {
      const accountInfo = await this.oracle.client.request({
        command: 'account_info',
        account: this.oracle.wallet.address
      });

      const correctSequence = accountInfo.result.account_data.Sequence;
      console.log(`Repairing sequence: ${this.oracle.sequence} -> ${correctSequence}`);
      this.oracle.sequence = correctSequence;
    } catch (error) {
      console.error('Failed to repair sequence:', error);
    }
  }

  async backoffDelay(attemptCount) {
    const baseDelay = 1000; // 1 second
    const maxDelay = 30000; // 30 seconds
    const delay = Math.min(baseDelay * Math.pow(2, attemptCount), maxDelay);
    
    console.log(`Backing off for ${delay}ms`);
    await new Promise(resolve => setTimeout(resolve, delay));
  }

  async sendAlert(alertType, data) {
    // In production, integrate with monitoring systems
    // Slack, PagerDuty, email, etc.
    const alert = {
      type: alertType,
      timestamp: new Date().toISOString(),
      oracle: this.oracle.wallet.address,
      data: data
    };

    console.error('ALERT:', JSON.stringify(alert, null, 2));
    
    // Could POST to monitoring webhook
    // await fetch('https://hooks.slack.com/...', {
    //   method: 'POST',
    //   body: JSON.stringify(alert)
    // });
  }

  getErrorSummary() {
    const summary = {
      totalErrors: Array.from(this.errorCounts.values()).reduce((a, b) => a + b, 0),
      errorTypes: Object.fromEntries(this.errorCounts),
      recentErrors: Array.from(this.lastErrors.entries())
        .filter(([_, data]) => Date.now() - data.timestamp < 3600000) // Last hour
        .map(([key, data]) => ({ type: key, error: data.error.message, timestamp: data.timestamp }))
    };

    return summary;
  }
}

class OracleMonitor {
  constructor(oracle) {
    this.oracle = oracle;
    this.metrics = {
      uptime: Date.now(),
      priceUpdates: 0,
      heartbeats: 0,
      errors: 0,
      sourceFailures: new Map(),
      transactionFees: [],
      dataLatency: []
    };
    this.healthCheckInterval = null;
    this.reportingInterval = null;
  }

  startMonitoring() {
    // Health check every 30 seconds
    this.healthCheckInterval = setInterval(async () => {
      await this.performHealthCheck();
    }, 30000);

    // Detailed report every 5 minutes
    this.reportingInterval = setInterval(() => {
      this.generateReport();
    }, 300000);

    console.log('Monitoring started');
  }

  async performHealthCheck() {
    const health = {
      timestamp: Date.now(),
      status: 'healthy',
      issues: []
    };

    // Check XRPL connectivity
    try {
      await this.oracle.client.request({
        command: 'server_info'
      });
    } catch (error) {
      health.status = 'degraded';
      health.issues.push('XRPL connectivity lost');
    }

    // Check account balance
    try {
      const accountInfo = await this.oracle.client.request({
        command: 'account_info',
        account: this.oracle.wallet.address
      });
      
      const balance = Number(accountInfo.result.account_data.Balance) / 1000000;
      if (balance < 10) {
        health.status = 'warning';
        health.issues.push(`Low balance: ${balance} XRP`);
      }
    } catch (error) {
      health.status = 'critical';
      health.issues.push('Cannot check account balance');
    }

    // Check data freshness
    if (this.oracle.lastPublishedPrice) {
      const dataAge = Date.now() - this.oracle.lastPublishedPrice.timestamp;
      if (dataAge > 600000) { // 10 minutes
        health.status = 'degraded';
        health.issues.push(`Stale data: ${Math.round(dataAge / 60000)} minutes old`);
      }
    }

    // Check error rates
    const recentErrors = this.getRecentErrorCount(300000); // 5 minutes
    const errorRate = recentErrors / Math.max(this.metrics.priceUpdates, 1);
    if (errorRate > 0.1) { // 10% error rate
      health.status = 'degraded';
      health.issues.push(`High error rate: ${(errorRate * 100).toFixed(1)}%`);
    }

    console.log(`Health check: ${health.status} (${health.issues.length} issues)`);
    
    if (health.issues.length > 0) {
      console.warn('Issues detected:', health.issues);
    }

    return health;
  }

  recordPriceUpdate(priceData, transactionHash) {
    this.metrics.priceUpdates++;
    
    if (transactionHash) {
      this.metrics.transactionFees.push({
        timestamp: Date.now(),
        fee: 12, // Our standard fee
        hash: transactionHash
      });
    }

    this.metrics.dataLatency.push({
      timestamp: Date.now(),
      latency: Date.now() - priceData.timestamp
    });

    // Keep only recent data to prevent memory leaks
    this.trimMetrics();
  }

  recordError(errorType, source = null) {
    this.metrics.errors++;
    
    if (source) {
      const count = this.metrics.sourceFailures.get(source) || 0;
      this.metrics.sourceFailures.set(source, count + 1);
    }
  }

  getRecentErrorCount(timeWindow) {
    // In production, this would query a proper time-series database
    // For now, approximate based on total errors and uptime
    const uptimeHours = (Date.now() - this.metrics.uptime) / 3600000;
    const recentWindow = Math.min(timeWindow / 3600000, uptimeHours);
    
    return Math.round(this.metrics.errors * (recentWindow / uptimeHours));
  }

  generateReport() {
    const uptime = Date.now() - this.metrics.uptime;
    const uptimeHours = uptime / 3600000;

    const report = {
      timestamp: new Date().toISOString(),
      uptime: {
        milliseconds: uptime,
        hours: uptimeHours.toFixed(2)
      },
      activity: {
        priceUpdates: this.metrics.priceUpdates,
        heartbeats: this.metrics.heartbeats,
        errors: this.metrics.errors,
        updateRate: (this.metrics.priceUpdates / uptimeHours).toFixed(2) + '/hour'
      },
      sources: {
        failures: Object.fromEntries(this.metrics.sourceFailures),
        totalSources: 3 // Our configured source count
      },
      performance: {
        averageLatency: this.getAverageLatency(),
        totalFees: this.getTotalFees()
      }
    };

    console.log('Oracle Report:', JSON.stringify(report, null, 2));
    return report;
  }

  getAverageLatency() {
    if (this.metrics.dataLatency.length === 0) return 0;
    
    const total = this.metrics.dataLatency.reduce((sum, entry) => sum + entry.latency, 0);
    return Math.round(total / this.metrics.dataLatency.length);
  }

  getTotalFees() {
    const totalDrops = this.metrics.transactionFees.reduce((sum, entry) => sum + entry.fee, 0);
    return (totalDrops / 1000000).toFixed(6) + ' XRP';
  }

  trimMetrics() {
    const maxAge = 24 * 3600000; // 24 hours
    const cutoff = Date.now() - maxAge;

    this.metrics.transactionFees = this.metrics.transactionFees.filter(entry => entry.timestamp > cutoff);
    this.metrics.dataLatency = this.metrics.dataLatency.filter(entry => entry.timestamp > cutoff);
  }

  stop() {
    if (this.healthCheckInterval) {
      clearInterval(this.healthCheckInterval);
    }
    
    if (this.reportingInterval) {
      clearInterval(this.reportingInterval);
    }

    console.log('Monitoring stopped');
  }
}

const xrpl = require('xrpl');
const fetch = require('node-fetch');

class ProductionOracle {
  constructor(config) {
    this.config = {
      seed: config.seed,
      testnet: config.testnet || true,
      updateThreshold: config.updateThreshold || 0.005,
      heartbeatInterval: config.heartbeatInterval || 300000, // 5 minutes
      ...config
    };

    this.dataSource = new DataSourceManager();
    this.oracle = new XRPLOracle(this.config.seed, this.config.testnet);
    this.errorHandler = new OracleErrorHandler(this.oracle);
    this.monitor = new OracleMonitor(this.oracle);
    
    this.running = false;
    this.mainLoop = null;
    this.heartbeatLoop = null;
  }

  async start() {
    console.log('Starting Production Oracle...');
    
    try {
      await this.oracle.connect();
      this.monitor.startMonitoring();
      
      // Main price update loop
      this.mainLoop = setInterval(async () => {
        await this.updatePrice();
      }, 60000); // Check every minute

      // Heartbeat loop
      this.heartbeatLoop = setInterval(async () => {
        await this.oracle.publishHeartbeat();
        this.monitor.metrics.heartbeats++;
      }, this.config.heartbeatInterval);

      this.running = true;
      console.log('Oracle started successfully');
      
      // Initial price update
      await this.updatePrice();
      
    } catch (error) {
      console.error('Failed to start oracle:', error);
      throw error;
    }
  }

  async updatePrice() {
    try {
      console.log('Fetching price data...');
      const priceData = await this.dataSource.aggregatePrices();
      
      console.log(`Aggregated price: $${priceData.price.toFixed(4)} (${priceData.sources} sources, ${(priceData.confidence * 100).toFixed(1)}% confidence)`);
      
      const txHash = await this.oracle.publishPrice(priceData);
      
      if (txHash) {
        this.monitor.recordPriceUpdate(priceData, txHash);
        console.log(`Price published: $${priceData.price.toFixed(4)}`);
      }
      
    } catch (error) {
      await this.errorHandler.handleDataSourceError('aggregation', error);
      this.monitor.recordError('price_update');
    }
  }

  async stop() {
    console.log('Stopping oracle...');
    this.running = false;
    
    if (this.mainLoop) clearInterval(this.mainLoop);
    if (this.heartbeatLoop) clearInterval(this.heartbeatLoop);
    
    this.monitor.stop();
    
    if (this.oracle.client.isConnected()) {
      await this.oracle.client.disconnect();
    }
    
    console.log('Oracle stopped');
  }

  getStatus() {
    return {
      running: this.running,
      address: this.oracle.wallet.address,
      lastPrice: this.oracle.lastPublishedPrice,
      health: this.monitor.performHealthCheck(),
      metrics: this.monitor.metrics
    };
  }
}

// Example usage and testing
async function runOracle() {
  // Generate test wallet (use existing seed in production)
  const testWallet = xrpl.Wallet.generate();
  console.log('Test wallet:', testWallet.address);
  console.log('Seed (save this):', testWallet.seed);
  
  const oracle = new ProductionOracle({
    seed: testWallet.seed,
    testnet: true,
    updateThreshold: 0.001 // 0.1% for testing
  });

  // Handle graceful shutdown
  process.on('SIGINT', async () => {
    console.log('\nShutdown requested...');
    await oracle.stop();
    process.exit(0);
  });

  try {
    await oracle.start();
    
    // Run for demonstration
    console.log('Oracle running... Press Ctrl+C to stop');
    
    // Status check every 5 minutes
    setInterval(() => {
      const status = oracle.getStatus();
      console.log('\n--- Oracle Status ---');
      console.log(`Running: ${status.running}`);
      console.log(`Address: ${status.address}`);
      if (status.lastPrice) {
        console.log(`Last Price: $${status.lastPrice.price.toFixed(4)} (${new Date(status.lastPrice.timestamp).toLocaleString()})`);
      }
      console.log(`Updates: ${status.metrics.priceUpdates}, Errors: ${status.metrics.errors}`);
    }, 300000);
    
  } catch (error) {
    console.error('Oracle failed:', error);
    await oracle.stop();
  }
}

// Export for use in other applications
module.exports = {
  ProductionOracle,
  DataSourceManager,
  XRPLOracle,
  OracleErrorHandler,
  OracleMonitor
};

// Run if called directly
if (require.main === module) {
  runOracle().catch(console.error);
}