Claim Creator Fees

Here are some code examples for Claiming Creator Fees using Blitzz API

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)

Rust

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 = "https://api.blitzz.fun";
const RPC_URL: &str = "https://api.mainnet-beta.solana.com";

#[derive(Serialize)]
struct ClaimRequest {
    #[serde(rename = "type")]
    tx_type: String,
    pool: String,
    creator: String,
    #[serde(rename = "prioFee")]
    prio_fee: f64,
}

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

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

    // Build unsigned transaction
    let request = ClaimRequest {
        tx_type: "claimCreatorFees".to_string(),
        pool: "pump".to_string(),
        creator: keypair.pubkey().to_string(),
        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!("Creator fees claimed! Signature: {}", signature);
    Ok(())
}

Blitzz Mode

Rust

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

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

#[derive(Serialize)]
struct ClaimRequest {
    #[serde(rename = "type")]
    tx_type: String,
    pool: String,
    creator: String,
    #[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 private_key = env::var("SOLANA_PRIVATE_KEY")?;
    
    // Parse keypair to get public key for creator field
    use solana_sdk::{signature::Keypair, signer::Signer};
    let keypair = Keypair::from_base58_string(&private_key);
    let creator = keypair.pubkey().to_string();

    // Build, sign, and send in one call
    let request = ClaimRequest {
        tx_type: "claimCreatorFees".to_string(),
        pool: "pump".to_string(),
        creator,
        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!("Creator fees claimed! Status: {}", res.status.unwrap());
    println!("Signature: {}", res.signature.unwrap());
    Ok(())
}