How to Setup Yield Farming Monitoring: Suspicious Activity Alerts in 2025

-- Monitor liquidity pool health
SELECT 
    block_time,
    token0_amount,
    token1_amount,
    (token0_amount * token1_amount) as liquidity_product
FROM uniswap_v3."Pool_evt_Swap"
WHERE pool = '0x[your_pool_address]'
    AND block_time > now() - interval '24 hours'
ORDER BY block_time DESC

// Monitor specific contract for suspicious activity
const monitorContract = async (contractAddress) => {
    const response = await fetch(
        `https://api.etherscan.io/api?module=account&action=txlist&address=${contractAddress}&sort=desc&apikey=${API_KEY}`
    );
    const data = await response.json();
    
    // Flag large outgoing transactions
    const suspiciousTransactions = data.result.filter(tx => 
        parseInt(tx.value) > 1000000000000000000 && // > 1 ETH
        tx.from.toLowerCase() === contractAddress.toLowerCase()
    );
    
    return suspiciousTransactions;
};

const Web3 = require('web3');
const web3 = new Web3('https://mainnet.infura.io/v3/YOUR_KEY');

class YieldFarmMonitor {
    constructor(farmAddress, userAddress) {
        this.farmAddress = farmAddress;
        this.userAddress = userAddress;
        this.alertThresholds = {
            positionDrop: 0.05, // 5% drop triggers alert
            liquidityDrop: 0.10, // 10% liquidity drop
            aprDrop: 0.20 // 20% APR drop
        };
    }
    
    async checkPositionHealth() {
        try {
            // Get current position value
            const positionValue = await this.getCurrentPositionValue();
            const previousValue = await this.getPreviousPositionValue();
            
            // Calculate percentage change
            const changePercent = (positionValue - previousValue) / previousValue;
            
            if (changePercent < -this.alertThresholds.positionDrop) {
                await this.sendAlert('POSITION_DROP', {
                    currentValue: positionValue,
                    previousValue: previousValue,
                    changePercent: changePercent
                });
            }
            
            return {
                healthy: changePercent > -this.alertThresholds.positionDrop,
                currentValue: positionValue,
                changePercent: changePercent
            };
        } catch (error) {
            console.error('Position health check failed:', error);
            await this.sendAlert('MONITORING_ERROR', { error: error.message });
        }
    }
}

class AlertManager {
    constructor(config) {
        this.config = config;
        this.channels = {
            discord: config.discordWebhook,
            telegram: config.telegramBot,
            email: config.emailService
        };
    }
    
    async sendMultiChannelAlert(alertType, data) {
        const message = this.formatAlertMessage(alertType, data);
        
        // Send to all configured channels
        const promises = Object.keys(this.channels).map(channel => 
            this.sendToChannel(channel, message)
        );
        
        await Promise.all(promises);
    }
    
    formatAlertMessage(alertType, data) {
        switch(alertType) {
            case 'POSITION_DROP':
                return `🚨 POSITION ALERT: ${data.changePercent.toFixed(2)}% drop detected
                Current Value: $${data.currentValue.toFixed(2)}
                Previous Value: $${data.previousValue.toFixed(2)}
                Time: ${new Date().toISOString()}`;
                
            case 'LIQUIDITY_WARNING':
                return `⚠️ LIQUIDITY ALERT: Pool liquidity dropped ${data.liquidityDrop.toFixed(2)}%
                Current Liquidity: $${data.currentLiquidity.toFixed(2)}
                Risk Level: ${data.riskLevel}`;
                
            default:
                return `📊 FARM MONITOR: ${alertType} - ${JSON.stringify(data)}`;
        }
    }
}

class SmartContractMonitor {
    constructor(contractAddress, contractABI) {
        this.contract = new web3.eth.Contract(contractABI, contractAddress);
        this.suspiciousPatterns = new Map();
    }
    
    async monitorEvents() {
        // Monitor critical events
        this.contract.events.Transfer({}, (error, event) => {
            if (error) return console.error('Event monitoring error:', error);
            
            this.analyzeTransferEvent(event);
        });
        
        this.contract.events.Approval({}, (error, event) => {
            if (error) return console.error('Event monitoring error:', error);
            
            this.analyzeApprovalEvent(event);
        });
    }
    
    analyzeTransferEvent(event) {
        const { from, to, value } = event.returnValues;
        const valueInEth = web3.utils.fromWei(value, 'ether');
        
        // Flag large single transfers
        if (parseFloat(valueInEth) > 1000) {
            this.flagSuspiciousActivity('LARGE_TRANSFER', {
                from: from,
                to: to,
                amount: valueInEth,
                transactionHash: event.transactionHash
            });
        }
        
        // Track transfer patterns
        this.trackTransferPattern(from, to, valueInEth);
    }
    
    trackTransferPattern(from, to, amount) {
        const key = `${from}-${to}`;
        
        if (!this.suspiciousPatterns.has(key)) {
            this.suspiciousPatterns.set(key, []);
        }
        
        const pattern = this.suspiciousPatterns.get(key);
        pattern.push({
            amount: parseFloat(amount),
            timestamp: Date.now()
        });
        
        // Keep only last 24 hours
        const dayAgo = Date.now() - (24 * 60 * 60 * 1000);
        const recentTransfers = pattern.filter(t => t.timestamp > dayAgo);
        this.suspiciousPatterns.set(key, recentTransfers);
        
        // Check for suspicious frequency
        if (recentTransfers.length > 50) {
            this.flagSuspiciousActivity('HIGH_FREQUENCY_TRANSFERS', {
                fromAddress: from,
                toAddress: to,
                transferCount: recentTransfers.length,
                totalAmount: recentTransfers.reduce((sum, t) => sum + t.amount, 0)
            });
        }
    }
}

class WhaleActivityMonitor {
    constructor() {
        this.whaleThreshold = 1000000; // $1M USD threshold
        this.knownWhales = new Set();
        this.whaleMovements = [];
    }
    
    async detectWhaleActivity(tokenAddress) {
        try {
            // Get top holders
            const holders = await this.getTopHolders(tokenAddress);
            
            for (const holder of holders) {
                if (holder.balance > this.whaleThreshold) {
                    this.knownWhales.add(holder.address);
                    await this.monitorWhaleAddress(holder.address);
                }
            }
        } catch (error) {
            console.error('Whale detection failed:', error);
        }
    }
    
    async monitorWhaleAddress(whaleAddress) {
        // Monitor recent transactions
        const recentTxs = await this.getRecentTransactions(whaleAddress);
        
        for (const tx of recentTxs) {
            const suspiciousActivity = this.analyzeTxForSuspiciousActivity(tx);
            
            if (suspiciousActivity.isSuspicious) {
                await this.alertWhaleActivity(whaleAddress, suspiciousActivity);
            }
        }
    }
    
    analyzeTxForSuspiciousActivity(transaction) {
        const analysis = {
            isSuspicious: false,
            reasons: [],
            riskLevel: 'LOW'
        };
        
        // Check for large outflows
        if (transaction.value > this.whaleThreshold * 0.1) {
            analysis.isSuspicious = true;
            analysis.reasons.push('LARGE_OUTFLOW');
            analysis.riskLevel = 'HIGH';
        }
        
        // Check for contract interactions
        if (transaction.to && transaction.input !== '0x') {
            analysis.reasons.push('CONTRACT_INTERACTION');
        }
        
        // Check transaction timing
        const now = Date.now();
        const txTime = transaction.timeStamp * 1000;
        const timeDiff = now - txTime;
        
        if (timeDiff < 300000) { // Less than 5 minutes ago
            analysis.reasons.push('RECENT_ACTIVITY');
            if (analysis.isSuspicious) {
                analysis.riskLevel = 'CRITICAL';
            }
        }
        
        return analysis;
    }
}

class EmergencyResponseSystem {
    constructor(userAddress, privateKey) {
        this.userAddress = userAddress;
        this.wallet = web3.eth.accounts.privateKeyToAccount(privateKey);
        this.emergencyActions = new Map();
    }
    
    async setupEmergencyWithdrawal(farmAddress, triggerConditions) {
        this.emergencyActions.set(farmAddress, {
            action: 'EMERGENCY_WITHDRAW',
            conditions: triggerConditions,
            lastCheck: Date.now()
        });
    }
    
    async executeEmergencyAction(farmAddress, actionType) {
        try {
            switch(actionType) {
                case 'EMERGENCY_WITHDRAW':
                    await this.emergencyWithdraw(farmAddress);
                    break;
                    
                case 'PAUSE_TRADING':
                    await this.pauseTrading(farmAddress);
                    break;
                    
                case 'REDUCE_POSITION':
                    await this.reducePosition(farmAddress, 0.5); // Reduce by 50%
                    break;
            }
            
            // Log action
            console.log(`Emergency action executed: ${actionType} for ${farmAddress}`);
            
        } catch (error) {
            console.error('Emergency action failed:', error);
            // Send critical alert
            await this.sendCriticalAlert(farmAddress, actionType, error);
        }
    }
    
    async emergencyWithdraw(farmAddress) {
        // Get farm contract
        const farmContract = new web3.eth.Contract(FARM_ABI, farmAddress);
        
        // Get user's staked balance
        const stakedBalance = await farmContract.methods
            .balanceOf(this.userAddress)
            .call();
        
        if (stakedBalance > 0) {
            // Create withdrawal transaction
            const withdrawTx = farmContract.methods.withdraw(stakedBalance);
            
            // Estimate gas
            const gasEstimate = await withdrawTx.estimateGas({
                from: this.userAddress
            });
            
            // Send transaction
            const signedTx = await web3.eth.accounts.signTransaction({
                to: farmAddress,
                data: withdrawTx.encodeABI(),
                gas: gasEstimate * 1.2, // 20% buffer
                gasPrice: web3.utils.toWei('50', 'gwei'), // High priority
                nonce: await web3.eth.getTransactionCount(this.userAddress)
            }, this.wallet.privateKey);
            
            const receipt = await web3.eth.sendSignedTransaction(signedTx.rawTransaction);
            
            return receipt;
        }
    }
}

class RiskAssessmentEngine {
    constructor() {
        this.riskFactors = {
            contractAge: { weight: 0.15, threshold: 30 }, // days
            totalValueLocked: { weight: 0.20, threshold: 1000000 }, // $1M
            auditStatus: { weight: 0.25, threshold: 1 },
            communityTrust: { weight: 0.20, threshold: 0.7 },
            liquidityStability: { weight: 0.20, threshold: 0.1 }
        };
    }
    
    async calculateRiskScore(protocolAddress) {
        const factors = await this.gatherRiskFactors(protocolAddress);
        let totalScore = 0;
        let maxScore = 0;
        
        for (const [factorName, config] of Object.entries(this.riskFactors)) {
            const factorValue = factors[factorName] || 0;
            const normalizedValue = this.normalizeFactor(factorName, factorValue, config);
            
            totalScore += normalizedValue * config.weight;
            maxScore += config.weight;
        }
        
        const riskScore = totalScore / maxScore;
        
        return {
            overallRisk: riskScore,
            factors: factors,
            recommendation: this.getRiskRecommendation(riskScore),
            alerts: this.generateRiskAlerts(factors)
        };
    }
    
    getRiskRecommendation(riskScore) {
        if (riskScore >= 0.8) return 'SAFE - Proceed with normal position size';
        if (riskScore >= 0.6) return 'MODERATE - Consider reduced position';
        if (riskScore >= 0.4) return 'HIGH RISK - Small position only';
        return 'EXTREME RISK - Avoid this protocol';
    }
    
    generateRiskAlerts(factors) {
        const alerts = [];
        
        if (factors.contractAge < 7) {
            alerts.push('⚠️ Very new contract (less than 1 week old)');
        }
        
        if (factors.auditStatus === 0) {
            alerts.push('🚨 No security audit found');
        }
        
        if (factors.liquidityStability > 0.3) {
            alerts.push('📉 Unstable liquidity (high volatility)');
        }
        
        return alerts;
    }
}

class DashboardDataCollector {
    constructor(userPositions) {
        this.userPositions = userPositions;
        this.updateInterval = 30000; // 30 seconds
        this.dataCache = new Map();
    }
    
    async collectAllData() {
        const dashboardData = {
            timestamp: Date.now(),
            totalPortfolioValue: 0,
            positions: [],
            alerts: [],
            marketMetrics: {}
        };
        
        // Collect position data
        for (const position of this.userPositions) {
            const positionData = await this.collectPositionData(position);
            dashboardData.positions.push(positionData);
            dashboardData.totalPortfolioValue += positionData.currentValue;
        }
        
        // Collect market metrics
        dashboardData.marketMetrics = await this.collectMarketMetrics();
        
        // Check for active alerts
        dashboardData.alerts = await this.collectActiveAlerts();
        
        return dashboardData;
    }
    
    async collectPositionData(position) {
        try {
            const farmContract = new web3.eth.Contract(position.abi, position.address);
            
            // Get position metrics
            const stakedBalance = await farmContract.methods
                .balanceOf(position.userAddress)
                .call();
                
            const currentAPR = await this.calculateCurrentAPR(position);
            const impermanentLoss = await this.calculateImpermanentLoss(position);
            
            return {
                name: position.name,
                address: position.address,
                stakedAmount: web3.utils.fromWei(stakedBalance, 'ether'),
                currentValue: await this.calculatePositionValue(position, stakedBalance),
                currentAPR: currentAPR,
                impermanentLoss: impermanentLoss,
                riskLevel: await this.assessPositionRisk(position),
                lastUpdate: Date.now()
            };
            
        } catch (error) {
            console.error(`Failed to collect data for ${position.name}:`, error);
            return {
                name: position.name,
                address: position.address,
                error: error.message,
                riskLevel: 'UNKNOWN'
            };
        }
    }
}

# docker-compose.yml for monitoring stack
version: '3.8'
services:
  yield-monitor:
    build: .
    environment:
      - NODE_ENV=production
      - WEB3_PROVIDER_URL=${WEB3_PROVIDER_URL}
      - ALERT_DISCORD_WEBHOOK=${DISCORD_WEBHOOK}
      - ALERT_TELEGRAM_BOT=${TELEGRAM_BOT}
    volumes:
      - ./data:/app/data
      - ./logs:/app/logs
    restart: unless-stopped
    
  redis:
    image: redis:alpine
    volumes:
      - redis_data:/data
    restart: unless-stopped
    
  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    restart: unless-stopped

volumes:
  redis_data:

// production-config.js
module.exports = {
    monitoring: {
        intervals: {
            positionCheck: 30000,    // 30 seconds
            whaleMonitoring: 60000,  // 1 minute
            riskAssessment: 300000,  // 5 minutes
            healthCheck: 10000       // 10 seconds
        },
        
        alerts: {
            channels: ['discord', 'telegram', 'email'],
            retryAttempts: 3,
            retryDelay: 5000,
            rateLimits: {
                critical: 0,      // No limit for critical alerts
                warning: 10,      // Max 10 per hour
                info: 5           // Max 5 per hour
            }
        },
        
        storage: {
            redis: {
                host: process.env.REDIS_HOST || 'localhost',
                port: process.env.REDIS_PORT || 6379,
                db: 0
            },
            dataRetention: {
                positions: '30d',
                alerts: '90d',
                metrics: '7d'
            }
        },
        
        security: {
            privateKeys: {
                encrypted: true,
                keyDerivation: 'pbkdf2',
                iterations: 100000
            },
            apiKeys: {
                rotation: '30d',
                storage: 'env'
            }
        }
    }
};

class OptimizedDataFetcher {
    constructor() {
        this.requestQueue = [];
        this.rateLimiter = new Map();
        this.cache = new Map();
        this.batchSize = 10;
    }
    
    async batchFetchPositions(positions) {
        // Group positions by provider to batch requests
        const grouped = this.groupByProvider(positions);
        const results = [];
        
        for (const [provider, providerPositions] of grouped) {
            const batchResults = await this.fetchBatch(provider, providerPositions);
            results.push(...batchResults);
        }
        
        return results;
    }
    
    async fetchBatch(provider, positions) {
        // Check rate limits
        if (this.isRateLimited(provider)) {
            await this.waitForRateLimit(provider);
        }
        
        // Create multicall for efficient batching
        const multicallData = positions.map(position => ({
            target: position.address,
            callData: this.encodeCall('balanceOf', [position.userAddress])
        }));
        
        try {
            const results = await this.executeMulticall(multicallData);
            this.updateRateLimit(provider);
            
            return this.processMulticallResults(positions, results);
            
        } catch (error) {
            console.error(`Batch fetch failed for ${provider}:`, error);
            // Fallback to individual calls
            return await this.fallbackIndividualCalls(positions);
        }
    }
    
    executeMulticall(callData) {
        const multicallContract = new web3.eth.Contract(
            MULTICALL_ABI, 
            MULTICALL_ADDRESS
        );
        
        return multicallContract.methods
            .aggregate(callData)
            .call();
    }
}

class MemoryOptimizedMonitor {
    constructor() {
        this.dataBuffer = new CircularBuffer(1000); // Keep last 1000 entries
        this.compressionEnabled = true;
        this.gcInterval = 300000; // 5 minutes
        
        // Setup automatic garbage collection
        setInterval(() => this.performGarbageCollection(), this.gcInterval);
    }
    
    addDataPoint(type, data) {
        const compressedData = this.compressionEnabled 
            ? this.compressData(data)
            : data;
            
        this.dataBuffer.push({
            timestamp: Date.now(),
            type: type,
            data: compressedData
        });
    }
    
    compressData(data) {
        // Remove unnecessary fields and compress numbers
        return {
            v: Math.round(data.value * 1000) / 1000, // 3 decimal places
            a: data.address.slice(0, 10), // Shortened address
            s: data.status
        };
    }
    
    performGarbageCollection() {
        // Clear old cache entries
        const cutoff = Date.now() - (24 * 60 * 60 * 1000); // 24 hours
        
        for (const [key, value] of this.cache.entries()) {
            if (value.timestamp < cutoff) {
                this.cache.delete(key);
            }
        }
        
        // Force V8 garbage collection if available
        if (global.gc) {
            global.gc();
        }
        
        console.log(`GC completed. Cache size: ${this.cache.size}`);
    }
}

class SecureMonitoringAccess {
    constructor() {
        this.accessLevels = {
            READ_ONLY: ['view_dashboard', 'view_alerts'],
            OPERATOR: ['view_dashboard', 'view_alerts', 'manage_alerts'],
            ADMIN: ['view_dashboard', 'view_alerts', 'manage_alerts', 'manage_positions', 'system_config']
        };
        
        this.sessions = new Map();
        this.auditLog = [];
    }
    
    async authenticateUser(apiKey, requiredPermission) {
        try {
            // Verify API key
            const user = await this.verifyApiKey(apiKey);
            if (!user) {
                this.logSecurityEvent('AUTH_FAILED', { apiKey: apiKey.slice(0, 8) + '...' });
                throw new Error('Invalid API key');
            }
            
            // Check permissions
            const userPermissions = this.accessLevels[user.role] || [];
            if (!userPermissions.includes(requiredPermission)) {
                this.logSecurityEvent('PERMISSION_DENIED', { 
                    user: user.id, 
                    permission: requiredPermission 
                });
                throw new Error('Insufficient permissions');
            }
            
            // Log successful access
            this.logSecurityEvent('ACCESS_GRANTED', { 
                user: user.id, 
                permission: requiredPermission 
            });
            
            return user;
            
        } catch (error) {
            console.error('Authentication failed:', error);
            throw error;
        }
    }
    
    logSecurityEvent(eventType, details) {
        this.auditLog.push({
            timestamp: Date.now(),
            type: eventType,
            details: details,
            ip: details.ip || 'unknown'
        });
        
        // Keep last 10000 events
        if (this.auditLog.length > 10000) {
            this.auditLog = this.auditLog.slice(-10000);
        }
        
        // Alert on suspicious activity
        if (eventType === 'AUTH_FAILED' || eventType === 'PERMISSION_DENIED') {
            this.checkForSuspiciousActivity(details);
        }
    }
}