Whale Watching and Copy Trading

Nova Agents make it easy to follow and replicate the strategies of crypto’s biggest players. By analyzing the activities of whales and Key Opinion Leaders (KOLs), you can align your trades with proven strategies.

• Copy Trading Simplified: Choose which whales or KOLs to follow, and Nova Agents will automatically replicate their trades.

• Risk Analysis: Assess the strategies of top traders and filter out risky moves.

• Custom Alerts: Receive notifications when specific wallets make significant trades, allowing you to act quickly.

This feature democratizes advanced trading strategies, putting the power of the market’s top players into the hands of everyday traders.

use std::collections::HashMap;

// Represents a trader's activity
#[derive(Debug, Clone)]
struct TraderActivity {
    address: String,
    trades: Vec<f64>, // List of trade values
    risk_level: f64,  // Risk level (0.0 = Low Risk, 1.0 = High Risk)
}

// Tracker for traders
struct CopyTradeTracker {
    traders: HashMap<String, TraderActivity>, // Address to activity mapping
    followed_traders: Vec<String>,            // List of followed trader addresses
}

impl CopyTradeTracker {
    // Initialize the tracker
    fn new() -> Self {
        CopyTradeTracker {
            traders: HashMap::new(),
            followed_traders: Vec::new(),
        }
    }

    // Add or update trader activity
    fn update_trader_activity(&mut self, address: String, trade: f64, risk_level: f64) {
        let trader = self.traders.entry(address.clone()).or_insert(TraderActivity {
            address: address.clone(),
            trades: Vec::new(),
            risk_level,
        });

        trader.trades.push(trade);
        trader.risk_level = risk_level; // Update risk level if it changes
    }

    // Follow a trader for copy trading
    fn follow_trader(&mut self, address: &str) {
        if self.traders.contains_key(address) && !self.followed_traders.contains(&address.to_string()) {
            self.followed_traders.push(address.to_string());
            println!("Now following trader: {}", address);
        }
    }

    // Copy trades from followed traders
    fn copy_trades(&self) {
        for address in &self.followed_traders {
            if let Some(trader) = self.traders.get(address) {
                println!(
                    "Replicating trades for {}: {:?}",
                    trader.address, trader.trades
                );
            }
        }
    }

    // Assess risk levels of traders
    fn assess_risk(&self) {
        for (_, trader) in &self.traders {
            let risk = if trader.risk_level < 0.3 {
                "Low Risk"
            } else if trader.risk_level > 0.7 {
                "High Risk"
            } else {
                "Moderate Risk"
            };

            println!(
                "Trader: {}\n  Risk Level: {:.2} ({})",
                trader.address, trader.risk_level, risk
            );
        }
    }

    // Send alerts for significant trades
    fn send_alerts(&self, trade_threshold: f64) {
        for (_, trader) in &self.traders {
            if let Some(&latest_trade) = trader.trades.last() {
                if latest_trade >= trade_threshold {
                    println!(
                        "Alert: Significant trade detected for {}: {:.2}",
                        trader.address, latest_trade
                    );
                }
            }
        }
    }
}

fn main() {
    let mut tracker = CopyTradeTracker::new();

    // Simulate trader activities
    tracker.update_trader_activity("Whale1".to_string(), 20_000.0, 0.5); // Moderate risk
    tracker.update_trader_activity("Whale1".to_string(), 50_000.0, 0.5);
    tracker.update_trader_activity("KOL1".to_string(), 10_000.0, 0.2); // Low risk
    tracker.update_trader_activity("KOL2".to_string(), 5_000.0, 0.8);  // High risk

    // Follow specific traders
    tracker.follow_trader("Whale1");
    tracker.follow_trader("KOL1");

    // Perform actions
    tracker.copy_trades();             // Replicate trades
    tracker.assess_risk();             // Assess trader risk
    tracker.send_alerts(15_000.0);     // Alert for trades above 15,000
}