do me a quick favor please and write this script without hard coding my api key and its using my config.toml  for the keys  use {
    anyhow::{anyhow, Result},
    base64::{Engine, engine::general_purpose::STANDARD as base64_engine},
    bincode,
    config::{Config, File},
    dashmap::DashMap,
    futures_util::{SinkExt, StreamExt},
    log::{debug, error, info, warn},
    pyo3::prelude::*,
    serde::{Deserialize, Serialize},
    serde_json::json,
    solana_client::rpc_client::RpcClient,
    solana_sdk::{
        compute_budget::ComputeBudgetInstruction,
        commitment_config::CommitmentConfig,
        message::Message,
        pubkey::Pubkey,
        signature::read_keypair_file,
        signer::{keypair::Keypair, Signer},
        transaction::Transaction,
        system_instruction,
    },
    spl_token,
    std::{
        sync::Arc,
        str::FromStr,
        time::{Duration, SystemTime, UNIX_EPOCH},
    },
    tokio::time::interval,
    colored::*,
    tokio_tungstenite::{connect_async, tungstenite::Message},
    rayon::prelude::*,
};

const WSOL_MINT: &str = "So11111111111111111111111111111111111111112";

struct TokenValidator {
    py_context: Python<'static>,
    tf_module: PyObject,
}

impl TokenValidator {
    fn new() -> Result<Self> {
        let py_context = Python::acquire_gil();
        let tf_module = PyModule::from_code(
            py_context,
            r#"
import tensorflow as tf

# Enable GPU memory growth
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
    for gpu in gpus:
        tf.config.experimental.set_memory_growth(gpu, True)

@tf.function(jit_compile=True)
def validate_token_batch(token_data):
    # Convert to GPU tensor
    data = tf.convert_to_tensor(token_data, dtype=tf.float32)
    
    # Parallel validation using GPU
    supply_check = tf.greater_equal(data[:, 0], 900000000.0)
    mutable_check = tf.equal(data[:, 1], 0.0)
    burnt_check = tf.equal(data[:, 2], 1.0)
    frozen_check = tf.equal(data[:, 3], 0.0)
    
    # Combine all checks
    valid_tokens = tf.logical_and(
        tf.logical_and(supply_check, mutable_check),
        tf.logical_and(burnt_check, frozen_check)
    )
    
    return valid_tokens.numpy()
            "#,
            "tf_validator.py",
            "tf_validator"
        )?;

        Ok(Self {
            py_context,
            tf_module: tf_module.into(),
        })
    }

    fn validate_batch(&self, token_data: Vec<[f32; 4]>) -> Result<Vec<bool>> {
        Python::with_gil(|py| {
            let validate_fn = self.tf_module.getattr(py, "validate_token_batch")?;
            let result = validate_fn.call1(py, (token_data,))?;
            Ok(result.extract::<Vec<bool>>(py)?)
        })
    }
}

struct Bot {
    config: BotConfig,
    rpc_client: Arc<RpcClient>,
    fallback_rpc: Arc<RpcClient>,
    keypair: Arc<Keypair>,
    active_trades: Arc<DashMap<String, Trade>>,
    http_client: reqwest::Client,
    validator: Arc<TokenValidator>,
}

impl Bot {
    async fn new() -> Result<Self> {
        println!("{}", "🚀 INITIALIZING MARGA FAST SNIPER WITH GPU ACCELERATION".bright_green().bold());
        
        let config_file = Config::builder()
            .add_source(File::with_name("config.toml"))
            .build()?;
            
        let bot_config: BotConfig = config_file.try_deserialize()?;

        let rpc_client = Arc::new(RpcClient::new_with_commitment(
            "https://marga-e56m84-fast-mainnet.helius-rpc.com/?api-key=1ea5843b-9daa-4926-a97a-be021922da2f",
            CommitmentConfig::confirmed(),
        ));
        
        let fallback_rpc = Arc::new(RpcClient::new_with_commitment(
            "https://mainnet.helius-rpc.com/?api-key=1ea5843b-9daa-4926-a97a-be021922da2f",
            CommitmentConfig::confirmed(),
        ));

        let keypair = read_keypair_file("C:\\Users\\Orsen\\.config\\solana\\id.json")?;
        
        let http_client = reqwest::Client::builder()
            .timeout(Duration::from_secs(5))
            .build()?;

        let validator = Arc::new(TokenValidator::new()?);

        println!("✅ GPU Acceleration Enabled");
        println!("✅ RPC Connection Active");
        println!("✅ WebSocket Stream Online");
        println!("💰 Using wallet: EHrpEhiBU13CygunXsmeGnzR6ircuYFQcFYPZT5BWUMA");

        Ok(Self {
            config: bot_config,
            rpc_client,
            fallback_rpc,
            keypair: Arc::new(keypair),
            active_trades: Arc::new(DashMap::new()),
            http_client,
            validator,
        })
    }

    async fn wrap_sol(&self, amount: f64) -> Result<()> {
        let lamports = (amount * 1e9) as u64;
        let wrap_ix = system_instruction::create_account(
            &self.keypair.pubkey(),
            &Pubkey::from_str("8sjB66HfESn3t6wDzKbxkJZdnpGyoykNjRQfZTn2fd5b")?,
            lamports,
            165,
            &spl_token::id(),
        );
        
        let init_ix = spl_token::instruction::initialize_account(
            &spl_token::id(),
            &Pubkey::from_str("8sjB66HfESn3t6wDzKbxkJZdnpGyoykNjRQfZTn2fd5b")?,
            &Pubkey::from_str(WSOL_MINT)?,
            &self.keypair.pubkey(),
        )?;

        let tx = Transaction::new_signed_with_payer(
            &[wrap_ix, init_ix],
            Some(&self.keypair.pubkey()),
            &[&self.keypair],
            self.rpc_client.get_latest_blockhash()?,
        );

        self.rpc_client.send_and_confirm_transaction_with_spinner(&tx)?;
        println!("✅ Wrapped {} SOL to WSOL", amount);
        Ok(())
    }

    async fn quick_buy(&self, token: &str) -> Result<()> {
        self.ensure_wsol_balance().await?;
        
        let priority_fee = 5000;
        let quote_url = format!(
            "https://quote-api.jup.ag/v6/quote?inputMint={}&outputMint={}&amount={}&slippageBps=15",
            WSOL_MINT, 
            token, 
            10000000
        );

        let quote = self.http_client
            .get(&quote_url)
            .send()
            .await?
            .json::<serde_json::Value>()
            .await?;

        let swap_request = json!({
            "quoteResponse": quote,
            "userPublicKey": "EHrpEhiBU13CygunXsmeGnzR6ircuYFQcFYPZT5BWUMA",
            "computeUnitPriceMicroLamports": priority_fee,
            "asLegacyTransaction": true
        });

        let swap_response = self.http_client
            .post("https://quote-api.jup.ag/v6/swap")
            .json(&swap_request)
            .send()
            .await?
            .json::<serde_json::Value>()
            .await?;

        let tx_data = base64_engine.decode(
            swap_response["swapTransaction"].as_str().unwrap()
        )?;
        
        let mut tx: Transaction = bincode::deserialize(&tx_data)?;

        // Optimize transaction with compute budget
        let compute_ix = ComputeBudgetInstruction::set_compute_unit_limit(1_400_000);
        let priority_ix = ComputeBudgetInstruction::set_compute_unit_price(priority_fee);
        
        let mut final_ixs = vec![compute_ix, priority_ix];
        final_ixs.extend(tx.message.instructions);
        
        let message = Message::new(&final_ixs, Some(&self.keypair.pubkey()));
        tx = Transaction::new(&[&self.keypair], message, self.rpc_client.get_latest_blockhash()?);

        // Send with parallel validation
        rayon::scope(|s| {
            s.spawn(|_| {
                if let Ok(signature) = self.rpc_client.send_and_confirm_transaction_with_spinner(&tx) {
                    println!("✅ Buy executed! Signature: {}", signature);
                }
            });
        });

        Ok(())
    }

    async fn run(&self) -> Result<()> {
        let ws_url = url::Url::parse("wss://marga-e56m84-fast-mainnet.helius-rpc.com")?;
        let backup_ws_url = url::Url::parse("wss://mainnet.helius-rpc.com/?api-key=1ea5843b-9daa-4926-a97a-be021922da2f")?;
        
        loop {
            let ws_stream = match connect_async(&ws_url).await {
                Ok(stream) => stream,
                Err(_) => connect_async(&backup_ws_url).await?,
            };

            let (mut write, mut read) = ws_stream.split();
            
            write.send(Message::Text(json!({
                "jsonrpc": "2.0",
                "id": 1,
                "method": "programSubscribe",
                "params": [
                    "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
                    {"encoding": "jsonParsed", "commitment": "confirmed"}
                ]
            }).to_string())).await?;

            println!("👀 GPU-Accelerated Token Scanning Active");

            while let Some(msg) = read.next().await {
                match msg {
                    Ok(Message::Text(text)) => {
                        let json: serde_json::Value = serde_json::from_str(&text)?;
                        
                        if let Some(params) = json.get("params") {
                            if let Some(token) = params["result"]["value"]["pubkey"].as_str() {
                                // GPU-accelerated validation
                                let token_data = vec![[900000000.0, 0.0, 1.0, 0.0]];
                                if self.validator.validate_batch(token_data)?.get(0).copied().unwrap_or(false) {
                                    tokio::spawn({
                                        let self_clone = self.clone();
                                        let token = token.to_string();
                                        async move {
                                            if let Err(e) = self_clone.quick_buy(&token).await {
                                                error!("Buy failed: {}", e);
                                            }
                                        }
                                    });
                                }
                            }
                        }
                    }
                    Err(e) => {
                        warn!("WebSocket error: {}", e);
                        break;
                    }
                    _ => {}
                }
            }

            tokio::time::sleep(Duration::from_secs(10)).await;
        }
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let bot = Arc::new(Bot::new().await?);
    println!("{}", "🤖 GPU-Accelerated Bot Ready!".bright_green().bold());

    ctrlc::set_handler(move || {
        println!("{}", "👋 Shutting down gracefully...".bright_yellow().bold());
        std::process::exit(0);
    })?;

    bot.run().await
}
 please if u wouldnt mind imy eyes are going bad i need the whole thing written without the errors