monitor.js

const { ethers } = require('ethers');
const axios = require('axios');
const cron = require('node-cron');
require('dotenv').config();

class BotMonitor {
    constructor() {
        this.provider = new ethers.providers.JsonRpcProvider(process.env.RPC_URL || 'https://arb1.arbitrum.io/rpc');
        this.wallet = process.env.BOT_PRIVATE_KEY ? new ethers.Wallet(process.env.BOT_PRIVATE_KEY, this.provider) : null;
        
        this.alerts = {
            lowBalance: false,
            highGas: false,
            noActivity: false,
            errors: []
        };
        
        this.stats = {
            startTime: Date.now(),
            settlements: 0,
            totalProfit: ethers.BigNumber.from(0),
            gasSpent: ethers.BigNumber.from(0),
            lastActivity: Date.now()
        };
        
        this.thresholds = {
            MIN_BALANCE: ethers.utils.parseEther('0.005'), // 0.005 ETH
            MAX_GAS_PRICE: ethers.utils.parseUnits('0.5', 'gwei'), // 0.5 gwei
            INACTIVITY_MINUTES: 30,
            ERROR_THRESHOLD: 5
        };
    }
    
    async checkWalletBalance() {
        if (!this.wallet) return;
        
        const balance = await this.wallet.getBalance();
        const balanceETH = parseFloat(ethers.utils.formatEther(balance));
        
        console.log(`Wallet Balance: ${balanceETH.toFixed(6)} ETH`);
        
        if (balance.lt(this.thresholds.MIN_BALANCE)) {
            if (!this.alerts.lowBalance) {
                this.alerts.lowBalance = true;
                await this.sendAlert('🚨 LOW BALANCE ALERT', `Wallet balance is ${balanceETH.toFixed(6)} ETH. Refill needed!`, 'error');
            }
        } else {
            this.alerts.lowBalance = false;
        }
        
        return balanceETH;
    }
    
    async checkGasPrice() {
        const gasPrice = await this.provider.getGasPrice();
        const gasPriceGwei = parseFloat(ethers.utils.formatUnits(gasPrice, 'gwei'));
        
        console.log(`Current Gas Price: ${gasPriceGwei.toFixed(3)} gwei`);
        
        if (gasPrice.gt(this.thresholds.MAX_GAS_PRICE)) {
            if (!this.alerts.highGas) {
                this.alerts.highGas = true;
                await this.sendAlert('⚠️ HIGH GAS ALERT', `Gas price is ${gasPriceGwei.toFixed(3)} gwei`, 'warning');
            }
        } else {
            this.alerts.highGas = false;
        }
        
        return gasPriceGwei;
    }
    
    async checkBotActivity() {
        // Check if bot log file exists and read recent activity
        const fs = require('fs');
        const path = require('path');
        const logPath = path.join(__dirname, 'bot.log');
        
        if (fs.existsSync(logPath)) {
            const stats = fs.statSync(logPath);
            const lastModified = stats.mtime;
            const minutesSinceActivity = (Date.now() - lastModified) / 1000 / 60;
            
            console.log(`Last bot activity: ${minutesSinceActivity.toFixed(1)} minutes ago`);
            
            if (minutesSinceActivity > this.thresholds.INACTIVITY_MINUTES) {
                if (!this.alerts.noActivity) {
                    this.alerts.noActivity = true;
                    await this.sendAlert(
                        '⏰ INACTIVITY ALERT',
                        `No bot activity for ${minutesSinceActivity.toFixed(0)} minutes`,
                        'warning'
                    );
                }
            } else {
                this.alerts.noActivity = false;
            }
            
            // Parse recent settlements from log
            try {
                const logs = fs.readFileSync(logPath, 'utf8').split('\n').slice(-100);
                const settlements = logs.filter(line => line.includes('Settlement complete')).length;
                console.log(`Recent settlements: ${settlements}`);
            } catch (error) {
                console.error('Error reading log file:', error.message);
            }
        }
    }
    
    async checkOracleStatus() {
        const ORACLE_ADDRESS = '0xa935db8cb0f45256e3df77cbff1980cf7aeffbe4';
        const ORACLE_ABI = ["function nextReportId() view returns (uint256)"];
        
        const oracle = new ethers.Contract(ORACLE_ADDRESS, ORACLE_ABI, this.provider);
        
        try {
            const nextId = await oracle.nextReportId();
            console.log(`Oracle Next Report ID: ${nextId}`);
            return nextId.toNumber();
        } catch (error) {
            console.error('Error checking oracle:', error.message);
            this.alerts.errors.push('Oracle check failed');
            return 0;
        }
    }
    
    async checkSystemHealth() {
        console.log('\n=== SYSTEM HEALTH CHECK ===');
        console.log(`Timestamp: ${new Date().toISOString()}`);
        
        const [balance, gasPrice, nextReportId] = await Promise.all([
            this.checkWalletBalance(),
            this.checkGasPrice(),
            this.checkOracleStatus()
        ]);
        
        await this.checkBotActivity();
        
        // Calculate uptime
        const uptimeHours = (Date.now() - this.stats.startTime) / 1000 / 60 / 60;
        console.log(`Monitor Uptime: ${uptimeHours.toFixed(2)} hours`);
        
        // Error threshold check
        if (this.alerts.errors.length > this.thresholds.ERROR_THRESHOLD) {
            await this.sendAlert(
                '🔥 CRITICAL ERROR THRESHOLD',
                `${this.alerts.errors.length} errors detected`,
                'critical'
            );
            this.alerts.errors = []; // Reset after alert
        }
        
        console.log('===========================\n');
        
        return {
            healthy: !this.alerts.lowBalance && !this.alerts.highGas && !this.alerts.noActivity,
            balance,
            gasPrice,
            nextReportId,
            uptime: uptimeHours
        };
    }
    
    async sendAlert(title, message, severity = 'info') {
        const webhook = process.env.DISCORD_WEBHOOK;
        if (!webhook) return;
        
        const colors = {
            info: 0x3498db,
            warning: 0xf39c12,
            error: 0xe74c3c,
            critical: 0x9b59b6
        };
        
        try {
            await axios.post(webhook, {
                embeds: [{
                    title,
                    description: message,
                    color: colors[severity],
                    timestamp: new Date().toISOString(),
                    footer: {
                        text: 'OpenOracle Settlement Bot Monitor'
                    }
                }]
            });
        } catch (error) {
            console.error('Failed to send Discord alert:', error.message);
        }
    }
    
    async generateReport() {
        const health = await this.checkSystemHealth();
        
        const report = {
            timestamp: new Date().toISOString(),
            health: health.healthy ? 'HEALTHY' : 'ISSUES DETECTED',
            metrics: {
                walletBalance: `${health.balance.toFixed(6)} ETH`,
                gasPrice: `${health.gasPrice.toFixed(3)} gwei`,
                nextReportId: health.nextReportId,
                uptime: `${health.uptime.toFixed(2)} hours`
            },
            alerts: {
                lowBalance: this.alerts.lowBalance,
                highGas: this.alerts.highGas,
                noActivity: this.alerts.noActivity,
                errorCount: this.alerts.errors.length
            }
        };
        
        // Save report
        const fs = require('fs');
        const reportPath = `./reports/health-${Date.now()}.json`;
        
        if (!fs.existsSync('./reports')) {
            fs.mkdirSync('./reports');
        }
        
        fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
        console.log(`Health report saved: ${reportPath}`);
        
        return report;
    }
    
    start() {
        console.log('Starting bot monitor...');
        
        // Initial check
        this.checkSystemHealth();
        
        // Schedule periodic checks
        cron.schedule('*/5 * * * *', () => {
            console.log('Running scheduled health check...');
            this.checkSystemHealth();
        });
        
        // Generate hourly reports
        cron.schedule('0 * * * *', () => {
            console.log('Generating hourly report...');
            this.generateReport();
        });
        
        // Daily summary
        cron.schedule('0 0 * * *', async () => {
            const report = await this.generateReport();
            await this.sendAlert(
                '📊 Daily Summary',
                `Health: ${report.health}\nBalance: ${report.metrics.walletBalance}\nUptime: ${report.metrics.uptime}`,
                'info'
            );
        });
        
        console.log('Monitor is running. Press Ctrl+C to stop.');
    }
}

// Start monitor
if (require.main === module) {
    const monitor = new BotMonitor();
    monitor.start();
}

module.exports = { BotMonitor };