Skip to main content

​
Local Trade Mode

You can also include transferConfig in your requests to /local-trade if you want to send through a transaction processor (e.g. Astralane, Jito, Helius Sender etc)
use anyhow::Result;
use base64::{engine::general_purpose::STANDARD as BASE64, Engine};
use serde::{Deserialize, Serialize};
use solana_client::rpc_client::RpcClient;
use solana_sdk::{signature::Keypair, signer::Signer, transaction::VersionedTransaction};
use std::env;

const BLITZZ_API: &str = "http://api.blitzz.fun";
const RPC_URL: &str = "https://api.mainnet-beta.solana.com";

#[derive(Serialize)]
struct BuyRequest {
    #[serde(rename = "type")]
    tx_type: String,
    pool: String,
    mint: String,
    payer: String,
    amount: u64,
    slippage_pct: f64,
    #[serde(rename = "prioFee")]
    prio_fee: f64,
}

#[derive(Deserialize)]
struct TxResponse {
    tx: Option<String>,
    error: Option<String>,
}

#[tokio::main]
async fn main() -> Result<()> {
    let mint = "YourTokenMintAddressHere";
    let sol_amount = 0.01;
    
    let private_key = env::var("SOLANA_PRIVATE_KEY")?;
    let keypair = Keypair::from_base58_string(&private_key);

    // Build unsigned transaction
    let request = BuyRequest {
        tx_type: "buy".to_string(),
        pool: "auto".to_string(),
        mint: mint.to_string(),
        payer: keypair.pubkey().to_string(),
        amount: (sol_amount * 1_000_000_000.0) as u64,
        slippage_pct: 1.0,
        prio_fee: 0.0005,
    };

    let client = reqwest::Client::new();
    let tx_res: TxResponse = client
        .post(format!("{}/local-trade", BLITZZ_API))
        .json(&request)
        .send()
        .await?
        .json()
        .await?;

    if let Some(error) = tx_res.error {
        anyhow::bail!("API error: {}", error);
    }

    // Sign and send transaction
    let tx_bytes = BASE64.decode(tx_res.tx.unwrap())?;
    let mut transaction: VersionedTransaction = bincode::deserialize(&tx_bytes)?;
    transaction.sign(&[&keypair], transaction.message.recent_blockhash());

    let rpc_client = RpcClient::new(RPC_URL);
    let signature = rpc_client.send_and_confirm_transaction(&transaction)?;

    println!("Buy successful! Signature: {}", signature);
    Ok(())
}

​
Blitzz Mode

use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::env;

const BLITZZ_API: &str = "http://api.blitzz.fun";

#[derive(Serialize)]
struct SellRequest {
    #[serde(rename = "type")]
    tx_type: String,
    pool: String,
    mint: String,
    amount: u64,
    slippage_pct: f64,
    #[serde(rename = "prioFee")]
    prio_fee: f64,
    #[serde(rename = "privateKey")]
    private_key: String,
}

#[derive(Deserialize)]
struct BlitzzResponse {
    status: Option<String>,
    signature: Option<String>,
    error: Option<String>,
}

#[tokio::main]
async fn main() -> Result<()> {
    let mint = "YourTokenMintAddressHere";
    let token_amount = 100.0;
    let private_key = env::var("SOLANA_PRIVATE_KEY")?;

    // Build, sign, and send in one call
    let request = SellRequest {
        tx_type: "sell".to_string(),
        pool: "auto".to_string(),
        mint: mint.to_string(),
        amount: (token_amount * 1_000_000.0) as u64,
        slippage_pct: 1.0,
        prio_fee: 0.0005,
        private_key,
    };

    let client = reqwest::Client::new();
    let res: BlitzzResponse = client
        .post(format!("{}/blitzz", BLITZZ_API))
        .json(&request)
        .send()
        .await?
        .json()
        .await?;

    if let Some(error) = res.error {
        anyhow::bail!("API error: {}", error);
    }

    println!("Sell successful! Status: {}", res.status.unwrap());
    println!("Signature: {}", res.signature.unwrap());
    Ok(())
}
⌘I