Parcel #acw2oc04i9f7egg

use std::{str::FromStr, sync::Arc};

use base64::{prelude::BASE64_STANDARD, Engine};
use dotenvy::var;
use reqwest::{header::AUTHORIZATION, Client};
use serde_json::{json, Value};
use solana_sdk::{
    compute_budget::ComputeBudgetInstruction,
    hash::Hash,
    instruction::Instruction,
    message::v0::Message,
    signature::{Keypair, Signature},
    signer::Signer,
    system_instruction,
    transaction::VersionedTransaction,
};

use crate::{
    consts::{BLOXROUTE_TIP, COMPUTE_UNIT_LIMIT},
    sender::TxSender,
    ARGS, PRIORITY_FEE_PRICE,
};

#[derive(Clone)]
pub(crate) struct BloxrouteTxSender {
    client: Arc<Client>,
    url: String,
    auth_key: String,
    provider: &'static str,
    offchain_tip: bool,
}

impl BloxrouteTxSender {
    pub(crate) fn new(url: String, auth_key: String, provider: &'static str) -> BloxrouteTxSender {
        BloxrouteTxSender {
            client: Arc::new(Client::new()),
            url,
            auth_key,
            provider,
            offchain_tip: var("BLOXROUTE_OFFCHAIN_TIP").unwrap_or("false".to_string()) == "true",
        }
    }
}

impl TxSender for BloxrouteTxSender {
    fn provider(&self) -> &'static str {
        self.provider
    }

    async fn warmup(&self) -> anyhow::Result<()> {
        let _ = self.client.get(&self.url).send().await?.text().await?;
        Ok(())
    }

    async fn send(&self, tx: VersionedTransaction) -> anyhow::Result<Signature> {
        let payload = if self.offchain_tip {
            json!({
                "transaction": {
                    "content": BASE64_STANDARD.encode(bincode::serialize(&tx).unwrap())
                },
                "skipPreFlight": true,
                "frontRunningProtection": false,
                "useStakedRPCs": true,
                "tip": ARGS.get().unwrap().tip_lamports
            })
        } else {
            json!({
                "transaction": {
                    "content": BASE64_STANDARD.encode(bincode::serialize(&tx).unwrap())
                },
                "skipPreFlight": true,
                "frontRunningProtection": false,
                "useStakedRPCs": true,
            })
        };

        let result: Value = self
            .client
            .post(&self.url)
            .json(&payload)
            .header(AUTHORIZATION, &self.auth_key)
            .send()
            .await?
            .json()
            .await?;

        if let Some(sig) = result["signature"].as_str() {
            Ok(Signature::from_str(sig)?)
        } else {
            anyhow::bail!("Failed to send transaction: {:?}", result);
        }
    }

    fn generate_txn(
        &self,
        signer: &Keypair,
        mut ixs: Vec<Instruction>,
        hash: Hash,
    ) -> anyhow::Result<VersionedTransaction> {
        ixs.push(ComputeBudgetInstruction::set_compute_unit_limit(
            COMPUTE_UNIT_LIMIT,
        ));
        ixs.push(ComputeBudgetInstruction::set_compute_unit_price(
            *PRIORITY_FEE_PRICE.get().unwrap(),
        ));

        if !self.offchain_tip {
            ixs.push(system_instruction::transfer(
                &signer.pubkey(),
                &BLOXROUTE_TIP,
                ARGS.get().unwrap().tip_lamports,
            ));
        }

        Ok(VersionedTransaction::try_new(
            solana_sdk::message::VersionedMessage::V0(Message::try_compile(
                &signer.pubkey(),
                &ixs,
                &[],
                hash,
            )?),
            &[signer],
        )?)
    }
}