init

#_sniper (Rust) using jito Shred stream/src/trading_loop.rs

@@ -0,0 +1,120 @@
+// trading_loop.rs
+
+use crate::common::utils::{
+    create_nonblocking_rpc_client, create_rpc_client, import_env_var, import_wallet, AppState,
+    SwapExecutionMode, SwapInput,
+};
+use crate::core::tx;
+use crate::dex::pump_fun::PUMP_PROGRAM;
+use crate::engine::swap::pump_swap;
+use dotenv::dotenv;
+use shared_state::{BuyOrder, SellOrder};
+use solana_sdk::{native_token, pubkey::Pubkey};
+use std::{
+    env,
+    str::FromStr,
+    sync::{Arc, OnceLock},
+};
+use tokio::sync::{mpsc::Receiver, Notify, OnceCell};
+
+static TRIGGER_NOTIFY: OnceCell<Arc<Notify>> = OnceCell::const_new();
+
+/// Exposed so `pub use trading_loop::get_notify_handle;` still works.
+pub async fn get_notify_handle() -> Arc<Notify> {
+    TRIGGER_NOTIFY
+        .get_or_init(|| async { Arc::new(Notify::new()) })
+        .await
+        .clone()
+}
+
+// Pre-parse these exactly once at program load:
+static PUMP_PROGRAM_KEY: OnceLock<Pubkey> = OnceLock::new();
+static LAMPORTS_PER_SOL_U64: OnceLock<u64> = OnceLock::new();
+
+pub async fn start_trading_loop(mut mint_rx: Receiver<BuyOrder>, mut sell_rx: Receiver<SellOrder>) {
+    // load .env if present
+    dotenv().ok();
+
+    // one-time RPC & wallet setup
+    let rpc = create_rpc_client().unwrap();
+    let rpc_nonblocking = create_nonblocking_rpc_client().await.unwrap();
+    let wallet = import_wallet().unwrap();
+
+    let app = AppState {
+        rpc_client: rpc.clone(),
+        rpc_nonblocking_client: rpc_nonblocking.clone(),
+        wallet: wallet.clone(),
+    };
+
+    // ─── SPAWN BLOCKHASH REFRESHER ───
+    // This will keep a fresh recent‐blockhash in the background so sends never stall
+    // ─── ONE-TIME TIP‐ENGINE INITIALIZATION ───
+    // Read your env vars just once
+    let block_engine = env::var("BLOCK_ENGINE_PROVIDER").unwrap_or_default();
+    let use_nextblock = block_engine.eq_ignore_ascii_case("nextblock");
+    let use_priority_tip = env::var("USE_PRIORITY_TIP")
+        .unwrap_or_default()
+        .eq_ignore_ascii_case("true");
+    // This will create/fetch your tip‐accounts and pull the first tip value
+    tx::init_tip_state(use_nextblock, use_priority_tip)
+        .await
+        .expect("failed to init tip engine");
+    // stash env vars once
+    let slippage_bps = import_env_var("SLIPPAGE").parse::<u16>().unwrap_or(15);
+    let buy_amount_sol = import_env_var("BUY_AMOUNT_SOL")
+        .parse::<f64>()
+        .unwrap_or(0.01);
+
+    // initialize our OnceLocks
+    let lamports_per_sol = *LAMPORTS_PER_SOL_U64.get_or_init(|| native_token::LAMPORTS_PER_SOL);
+    let buy_amount_lamports = (buy_amount_sol * lamports_per_sol as f64) as u64;
+    let pump_program_key =
+        *PUMP_PROGRAM_KEY.get_or_init(|| Pubkey::from_str(PUMP_PROGRAM).unwrap());
+
+    loop {
+        tokio::select! {
+            // ───────── BUY ORDERS ─────────
+            Some(BuyOrder { mint, creator, use_jito, urgent }) = mint_rx.recv() => {
+                let mint_pk = Pubkey::from_str(&mint).unwrap();
+                // derive creator vault address
+                let (creator_vault, _) =
+                    Pubkey::find_program_address(&[b"creator-vault", creator.as_ref()], &pump_program_key);
+
+                let input = SwapInput {
+                    input_token_mint:  spl_token::native_mint::ID,
+                    output_token_mint: mint_pk,
+                    slippage_bps,
+                    amount:            buy_amount_lamports,
+                    mode:              SwapExecutionMode::ExactIn,
+                    market:            None,
+                    creator_vault:     Some(creator_vault),
+                };
+
+                let app_clone = app.clone();
+                tokio::spawn(async move {
+                    let _ = pump_swap(app_clone, input, "buy", use_jito, urgent).await;
+                });
+            }
+
+            // ───────── SELL ORDERS ────────
+            Some(SellOrder { mint, amount, use_jito, urgent }) = sell_rx.recv() => {
+                let mint_pk = Pubkey::from_str(&mint).unwrap();
+
+                let input = SwapInput {
+                    input_token_mint:  mint_pk,
+                    output_token_mint: spl_token::native_mint::ID,
+                    slippage_bps,
+                    amount,
+                    mode:              SwapExecutionMode::ExactOut,
+                    market:            None,
+                    creator_vault:     None,
+                };
+
+                let app_clone = app.clone();
+                tokio::spawn(async move {
+                    let _ = pump_swap(app_clone, input, "sell", use_jito, urgent).await;
+                });
+            }
+        }
+    }
+}