@pioneer-platform/pioneer-discovery-service 0.2.1 → 0.2.2

package/src/workers/price-discovery.worker.ts

@@ -0,0 +1,397 @@
+/**
+ * Price Discovery Worker
+ * 
+ * Background worker that:
+ * 1. Discovers alternative free price data sources
+ * 2. Monitors primary asset prices for empty/missing data
+ * 3. Sends Discord alerts for critical price issues
+ * 4. Maintains a database of working price sources
+ * 
+ * This runs as part of the discovery service cron cycle
+ */
+
+import axios from 'axios';
+import { discoveryDB } from '../db';
+
+const log = require('@pioneer-platform/loggerdog')();
+const TAG = ' | price-discovery | ';
+
+// CRITICAL: Major cryptocurrencies that should NEVER have empty prices
+const PRIMARY_ASSETS = [
+    { caip: 'bip122:000000000019d6689c085ae165831e93/slip44:0', symbol: 'bitcoin', name: 'Bitcoin (BTC)' },
+    { caip: 'eip155:1/slip44:60', symbol: 'ethereum', name: 'Ethereum (ETH)' },
+    { caip: 'eip155:56/slip44:60', symbol: 'binancecoin', name: 'BNB Chain (BNB)' },
+    { caip: 'eip155:137/slip44:60', symbol: 'matic-network', name: 'Polygon (MATIC)' },
+    { caip: 'cosmos:cosmoshub-4/slip44:118', symbol: 'cosmos', name: 'Cosmos (ATOM)' },
+    { caip: 'cosmos:thorchain-mainnet-v1/slip44:931', symbol: 'thorchain', name: 'Thorchain (RUNE)' },
+    { caip: 'bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2', symbol: 'litecoin', name: 'Litecoin (LTC)' },
+    { caip: 'bip122:00000000001a91e3dace36e2be3bf030/slip44:3', symbol: 'dogecoin', name: 'Dogecoin (DOGE)' },
+];
+
+// Free price API sources (no API key required)
+const FREE_PRICE_SOURCES = [
+    {
+        name: 'CoinGecko (Free)',
+        url: 'https://api.coingecko.com/api/v3/simple/price',
+        rateLimit: { requests: 10, perMinutes: 1 },
+        priority: 1,
+    },
+    {
+        name: 'Blockchain.com',
+        url: 'https://blockchain.info/ticker',
+        rateLimit: { requests: 600, perHour: 1 },
+        priority: 2,
+    },
+    {
+        name: 'CoinPaprika',
+        url: 'https://api.coinpaprika.com/v1/tickers',
+        rateLimit: { requests: 20, perMinutes: 1 },
+        priority: 3,
+    },
+    {
+        name: 'CryptoCompare',
+        url: 'https://min-api.cryptocompare.com/data/price',
+        rateLimit: { requests: 100, perHour: 1 },
+        priority: 4,
+    },
+    {
+        name: 'Binance Public',
+        url: 'https://api.binance.com/api/v3/ticker/price',
+        rateLimit: { requests: 1200, perMinutes: 1 },
+        priority: 5,
+    },
+    {
+        name: 'Kraken Public',
+        url: 'https://api.kraken.com/0/public/Ticker',
+        rateLimit: { requests: 1, perSecond: 1 },
+        priority: 6,
+    },
+    {
+        name: 'Coinbase Public',
+        url: 'https://api.coinbase.com/v2/exchange-rates',
+        rateLimit: { requests: 10, perSecond: 1 },
+        priority: 7,
+    },
+];
+
+interface PriceSourceStatus {
+    name: string;
+    url: string;
+    working: boolean;
+    lastChecked: number;
+    lastPrice?: number;
+    responseTime?: number;
+    error?: string;
+}
+
+interface PriceCheckResult {
+    asset: string;
+    hasPrice: boolean;
+    price?: number;
+    source?: string;
+    checked: number;
+}
+
+export class PriceDiscoveryWorker {
+    private priceSourceCache: Map<string, PriceSourceStatus> = new Map();
+    private discordNotifier: any;
+
+    constructor() {
+        // Initialize Discord notifier if available
+        this.initDiscordNotifier();
+    }
+
+    private async initDiscordNotifier() {
+        try {
+            // Try to import discord notifier from pioneer-server if available
+            // This will fail gracefully if running standalone
+            const notifierPath = '../../../pioneer-server/src/services/discord-notifier.service';
+            const { discordNotifier } = await import(notifierPath);
+            if (discordNotifier && typeof discordNotifier.isEnabled === 'function' && discordNotifier.isEnabled()) {
+                this.discordNotifier = discordNotifier;
+                log.info(TAG, '✅ Discord notifier connected for price alerts');
+            }
+        } catch (error) {
+            log.debug(TAG, 'Discord notifier not available (standalone mode) - this is OK');
+        }
+    }
+
+    /**
+     * Main discovery run - called by the discovery agent
+     */
+    async run(): Promise<void> {
+        const tag = TAG + 'run | ';
+        log.info(tag, '🔍 Starting price discovery worker...');
+
+        try {
+            // Phase 1: Test all free price sources
+            await this.discoverPriceSources();
+
+            // Phase 2: Check primary assets for empty prices
+            await this.monitorPrimaryAssets();
+
+            // Phase 3: Report findings
+            await this.reportFindings();
+
+            log.info(tag, '✅ Price discovery worker completed');
+        } catch (error) {
+            log.error(tag, '❌ Price discovery worker failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Phase 1: Discover and test free price sources
+     */
+    private async discoverPriceSources(): Promise<void> {
+        const tag = TAG + 'discoverPriceSources | ';
+        log.info(tag, `Testing ${FREE_PRICE_SOURCES.length} free price sources...`);
+
+        for (const source of FREE_PRICE_SOURCES) {
+            try {
+                const status = await this.testPriceSource(source);
+                this.priceSourceCache.set(source.name, status);
+
+                if (status.working) {
+                    log.info(tag, `✅ ${source.name} - Working (${status.responseTime}ms)`);
+                } else {
+                    log.warn(tag, `❌ ${source.name} - Failed: ${status.error}`);
+                }
+
+                // Small delay to respect rate limits
+                await new Promise(resolve => setTimeout(resolve, 500));
+            } catch (error) {
+                log.error(tag, `Error testing ${source.name}:`, error);
+            }
+        }
+
+        const workingCount = Array.from(this.priceSourceCache.values()).filter(s => s.working).length;
+        log.info(tag, `Price source discovery complete: ${workingCount}/${FREE_PRICE_SOURCES.length} working`);
+    }
+
+    /**
+     * Test a single price source
+     */
+    private async testPriceSource(source: typeof FREE_PRICE_SOURCES[0]): Promise<PriceSourceStatus> {
+        const tag = TAG + 'testPriceSource | ';
+        const startTime = Date.now();
+
+        const status: PriceSourceStatus = {
+            name: source.name,
+            url: source.url,
+            working: false,
+            lastChecked: Date.now(),
+        };
+
+        try {
+            let price: number | undefined;
+
+            // Test with Bitcoin as the reference asset
+            switch (source.name) {
+                case 'CoinGecko (Free)':
+                    const cgResponse = await axios.get(`${source.url}?ids=bitcoin&vs_currencies=usd`, {
+                        timeout: 5000,
+                    });
+                    price = cgResponse.data?.bitcoin?.usd;
+                    break;
+
+                case 'Blockchain.com':
+                    const bcResponse = await axios.get(source.url, { timeout: 5000 });
+                    price = bcResponse.data?.USD?.last;
+                    break;
+
+                case 'CoinPaprika':
+                    const cpResponse = await axios.get(`${source.url}/btc-bitcoin`, { timeout: 5000 });
+                    price = cpResponse.data?.quotes?.USD?.price;
+                    break;
+
+                case 'CryptoCompare':
+                    const ccResponse = await axios.get(`${source.url}?fsym=BTC&tsyms=USD`, {
+                        timeout: 5000,
+                    });
+                    price = ccResponse.data?.USD;
+                    break;
+
+                case 'Binance Public':
+                    const binanceResponse = await axios.get(`${source.url}?symbol=BTCUSDT`, {
+                        timeout: 5000,
+                    });
+                    price = parseFloat(binanceResponse.data?.price);
+                    break;
+
+                case 'Kraken Public':
+                    const krakenResponse = await axios.get(`${source.url}?pair=XBTUSD`, {
+                        timeout: 5000,
+                    });
+                    price = parseFloat(krakenResponse.data?.result?.XXBTZUSD?.c?.[0]);
+                    break;
+
+                case 'Coinbase Public':
+                    const coinbaseResponse = await axios.get(`${source.url}?currency=BTC`, {
+                        timeout: 5000,
+                    });
+                    price = parseFloat(coinbaseResponse.data?.data?.rates?.USD);
+                    break;
+            }
+
+            const responseTime = Date.now() - startTime;
+
+            if (price && price > 0) {
+                status.working = true;
+                status.lastPrice = price;
+                status.responseTime = responseTime;
+                log.debug(tag, `${source.name}: $${price} (${responseTime}ms)`);
+            } else {
+                status.error = 'No price data returned';
+            }
+        } catch (error: any) {
+            status.error = error.message || 'Unknown error';
+            status.responseTime = Date.now() - startTime;
+            log.debug(tag, `${source.name} failed:`, status.error);
+        }
+
+        return status;
+    }
+
+    /**
+     * Phase 2: Monitor primary assets for empty prices
+     */
+    private async monitorPrimaryAssets(): Promise<void> {
+        const tag = TAG + 'monitorPrimaryAssets | ';
+        log.info(tag, `Checking prices for ${PRIMARY_ASSETS.length} primary assets...`);
+
+        const results: PriceCheckResult[] = [];
+
+        for (const asset of PRIMARY_ASSETS) {
+            try {
+                const result = await this.checkAssetPrice(asset);
+                results.push(result);
+
+                if (!result.hasPrice) {
+                    log.error(tag, `🚨 EMPTY PRICE: ${asset.name} (${asset.caip})`);
+
+                    // Send Discord alert (rate limited to 1 per 24h per asset)
+                    if (this.discordNotifier) {
+                        await this.discordNotifier.sendEmptyPriceAlert(asset.caip, asset.name);
+                    }
+                } else {
+                    log.debug(tag, `✅ ${asset.name}: $${result.price} (from ${result.source})`);
+                }
+
+                // Small delay between checks
+                await new Promise(resolve => setTimeout(resolve, 300));
+            } catch (error) {
+                log.error(tag, `Error checking ${asset.name}:`, error);
+            }
+        }
+
+        const emptyCount = results.filter(r => !r.hasPrice).length;
+        if (emptyCount > 0) {
+            log.warn(tag, `⚠️ Found ${emptyCount} primary assets with empty prices!`);
+        } else {
+            log.info(tag, '✅ All primary assets have valid prices');
+        }
+    }
+
+    /**
+     * Check if an asset has a valid price using working sources
+     */
+    private async checkAssetPrice(asset: typeof PRIMARY_ASSETS[0]): Promise<PriceCheckResult> {
+        const tag = TAG + 'checkAssetPrice | ';
+
+        // Try working sources in priority order
+        const workingSources = Array.from(this.priceSourceCache.values())
+            .filter(s => s.working)
+            .sort((a, b) => {
+                const aPriority = FREE_PRICE_SOURCES.find(f => f.name === a.name)?.priority || 999;
+                const bPriority = FREE_PRICE_SOURCES.find(f => f.name === b.name)?.priority || 999;
+                return aPriority - bPriority;
+            });
+
+        if (workingSources.length === 0) {
+            log.warn(tag, 'No working price sources available');
+            return {
+                asset: asset.name,
+                hasPrice: false,
+                checked: Date.now(),
+            };
+        }
+
+        // Try first working source
+        const source = workingSources[0];
+
+        try {
+            // For simplicity, we'll use CoinGecko format for all (could be extended)
+            if (source.name === 'CoinGecko (Free)') {
+                const response = await axios.get(
+                    `${source.url}?ids=${asset.symbol}&vs_currencies=usd`,
+                    { timeout: 5000 }
+                );
+                const price = response.data?.[asset.symbol]?.usd;
+
+                return {
+                    asset: asset.name,
+                    hasPrice: !!(price && price > 0),
+                    price,
+                    source: source.name,
+                    checked: Date.now(),
+                };
+            }
+
+            // Fallback: assume no price
+            return {
+                asset: asset.name,
+                hasPrice: false,
+                checked: Date.now(),
+            };
+        } catch (error) {
+            log.debug(tag, `Failed to check price for ${asset.name}:`, error);
+            return {
+                asset: asset.name,
+                hasPrice: false,
+                checked: Date.now(),
+            };
+        }
+    }
+
+    /**
+     * Phase 3: Report findings
+     */
+    private async reportFindings(): Promise<void> {
+        const tag = TAG + 'reportFindings | ';
+
+        const workingSources = Array.from(this.priceSourceCache.values()).filter(s => s.working);
+        const failedSources = Array.from(this.priceSourceCache.values()).filter(s => !s.working);
+
+        log.info(tag, '\n📊 Price Discovery Report:');
+        log.info(tag, `   Working Sources: ${workingSources.length}`);
+        log.info(tag, `   Failed Sources: ${failedSources.length}`);
+
+        if (workingSources.length > 0) {
+            log.info(tag, '\n✅ Working Price Sources:');
+            for (const source of workingSources) {
+                log.info(tag, `   - ${source.name}: $${source.lastPrice} (${source.responseTime}ms)`);
+            }
+        }
+
+        if (failedSources.length > 0) {
+            log.warn(tag, '\n❌ Failed Price Sources:');
+            for (const source of failedSources) {
+                log.warn(tag, `   - ${source.name}: ${source.error}`);
+            }
+        }
+
+        // TODO: Save findings to MongoDB for historical tracking
+    }
+
+    /**
+     * Get current status of all price sources
+     */
+    getSourceStatus(): PriceSourceStatus[] {
+        return Array.from(this.priceSourceCache.values());
+    }
+}
+
+// Export singleton instance
+export const priceDiscoveryWorker = new PriceDiscoveryWorker();
+