feat : add strategy

tests/copy_trade_strategy.rs

@@ -0,0 +1,26 @@
+use crate::bot::strategies::copy_trade_strategy::CopyTradeStrategy;
+use solana_sdk::pubkey::Pubkey;
+use std::collections::HashMap;
+
+#[tokio::test]
+async fn test_copy_trade_strategy() {
+    let rpc_client = solana_client::rpc_client::RpcClient::new("https://api.mainnet-beta.solana.com".to_string());
+    let mut strategy = CopyTradeStrategy::new(rpc_client);
+    
+    strategy.set_trade_threshold(1000.0);
+    strategy.set_max_trade_amount(10000.0);
+    
+    let trader_account = Pubkey::new_unique();
+    let mut target_accounts = HashMap::new();
+    target_accounts.insert(trader_account, crate::AccountInfo {
+        token_balance: 0.0,
+        token_price: 0.0,
+    });
+    
+    let targets = strategy.find_opportunities(&target_accounts).await;
+    assert_eq!(targets.len(), 1);
+    
+    let target = &targets[0];
+    assert_eq!(target.trader_account, trader_account);
+    assert_eq!(target.trade_amount, 5000.0);
+}

tests/integration_tests.rs

@@ -0,0 +1,68 @@
+use mev_bot_solana::bot::solana_mev_bot::SolanaMevBot;
+use mev_bot_solana::config::Config;
+use mev_bot_solana::dex::dex_manager::DexManager;
+use mev_bot_solana::monitoring::metrics::Metrics;
+use mev_bot_solana::strategies::copy_trade_strategy::CopyTradeStrategy;
+use mev_bot_solana::strategies::sniping_strategy::SnipingStrategy;
+use mev_bot_solana::utils::config_parser::parse_config;
+use solana_client::rpc_client::RpcClient;
+use solana_sdk::signature::read_keypair_file;
+use std::sync::Arc;
+
+#[tokio::test]
+async fn test_mev_bot_integration() {
+    let config = parse_config("config.toml").expect("Failed to parse config");
+
+    let rpc_client = Arc::new(RpcClient::new_with_commitment(
+        config.solana.rpc_url.clone(),
+        config.solana.commitment.clone(),
+    ));
+
+    let metrics = Arc::new(Metrics::new());
+
+    let dex_manager = Arc::new(tokio::sync::Mutex::new(DexManager::new(
+        rpc_client.clone(),
+        config.dexes.clone(),
+    )));
+
+    let sniping_strategy = Arc::new(tokio::sync::Mutex::new(SnipingStrategy::new(
+        rpc_client.clone(),
+        dex_manager.clone(),
+        config.bot.max_position_size,
+    )));
+
+    let copy_trade_strategy = Arc::new(tokio::sync::Mutex::new(CopyTradeStrategy::new(
+        rpc_client.clone(),
+        dex_manager.clone(),
+        config.bot.max_position_size,
+    )));
+
+    let authority_keypair = read_keypair_file(config.bot.keypair_path.clone())
+        .expect("Failed to read keypair file");
+
+    let mut mev_bot = SolanaMevBot::new(
+        rpc_client,
+        authority_keypair,
+        vec![
+            sniping_strategy.clone(),
+            copy_trade_strategy.clone(),
+        ],
+        config.bot.profit_threshold,
+        metrics,
+    );
+
+    tokio::spawn(async move {
+        mev_bot.run().await;
+    });
+
+    tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
+
+    let orders = mev_bot.metrics.get_orders().await;
+    assert!(!orders.is_empty());
+
+    let profits = mev_bot.metrics.get_profits().await;
+    assert!(!profits.is_empty());
+
+    let volumes = mev_bot.metrics.get_volumes().await;
+    assert!(!volumes.is_empty());
+}

tests/sniping_strategy.rs

@@ -0,0 +1,29 @@
+use crate::bot::strategies::sniping_strategy::SnipingStrategy;
+use solana_sdk::pubkey::Pubkey;
+use std::collections::HashMap;
+
+#[tokio::test]
+async fn test_sniping_strategy() {
+    let rpc_client = solana_client::rpc_client::RpcClient::new("https://api.mainnet-beta.solana.com".to_string());
+    let mut strategy = SnipingStrategy::new(rpc_client);
+    
+    let token_mint = Pubkey::new_unique();
+    strategy.add_target_token(token_mint);
+    strategy.set_max_price(10.0);
+    strategy.set_min_liquidity(1000.0);
+    
+    let mut target_accounts = HashMap::new();
+    target_accounts.insert(token_mint, crate::AccountInfo {
+        token_balance: 5000.0,
+        token_price: 8.0,
+    });
+    
+    let opportunities = strategy.find_opportunities(&target_accounts).await;
+    assert_eq!(opportunities.len(), 1);
+    
+    let opportunity = &opportunities[0];
+    assert_eq!(opportunity.target_account, token_mint);
+    assert_eq!(opportunity.token_mint, token_mint);
+    assert_eq!(opportunity.expected_price, 8.0);
+    assert_eq!(opportunity.token_balance, 5000.0);
+}

tests/solana_mev_bot.rs

@@ -0,0 +1,40 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+use solana_mev_bot::bot::solana_mev_bot::SolanaMevBot;
+use solana_mev_bot::dex::{raydium, serum, orca};
+use solana_mev_bot::strategies::{sniping_strategy, copy_trade_strategy};
+use solana_mev_bot::utils::solana;
+
+#[tokio::test]
+async fn test_solana_mev_bot() {
+    let rpc_url = "https://api.devnet.solana.com";
+    let ws_url = "wss://api.devnet.solana.com";
+    let payer_keypair = solana::load_keypair("path/to/keypair.json");
+    let target_accounts = HashMap::new();
+    let profit_threshold = 0.01;
+
+    let rpc_client = Arc::new(solana_client::rpc_client::RpcClient::new_with_commitment(
+        rpc_url.to_string(),
+        solana_sdk::commitment_config::CommitmentConfig::confirmed(),
+    ));
+
+    let mut solana_mev_bot = SolanaMevBot::new(
+        rpc_client.clone(),
+        ws_url.to_string(),
+        payer_keypair,
+        target_accounts,
+        profit_threshold,
+        vec![
+            Arc::new(Mutex::new(raydium::Raydium::new(rpc_client.clone()))),
+            Arc::new(Mutex::new(serum::Serum::new(rpc_client.clone()))),
+            Arc::new(Mutex::new(orca::Orca::new(rpc_client.clone()))),
+        ],
+        Arc::new(Mutex::new(sniping_strategy::SnipingStrategy::new(rpc_client.clone()))),
+        Arc::new(Mutex::new(copy_trade_strategy::CopyTradeStrategy::new(rpc_client.clone()))),
+    );
+
+    let result = solana_mev_bot.run().await;
+    assert!(result.is_ok());
+}