PumpFun Rust SDK

A comprehensive Rust SDK for seamless interaction with the PumpFun Solana program. This SDK provides a robust set of tools and interfaces to integrate PumpFun functionality into your applications.

Explanation

1. Add logs_filters to parse the logs.
2. Add logs_parser to process the logs.
3. Add logs_data to define the data structure of the logs.
4. Add trade events to define the event of the logs.
5. Add logs_subscribe to subscribe the logs of the PumpFun program.
6. Add jito to send transaction with Jito.
7. Add yellowstone grpc to subscribe the logs of the PumpFun program.

Usage

logs subscription for token create and trade transaction

use mai3_pumpfun_sdk::common::{
    logs_events::DexEvent,
    logs_subscribe::{tokens_subscription, stop_subscription}
};
use solana_sdk::commitment_config::CommitmentConfig;

println!("Starting token subscription...");

// wss 
let ws_url = "wss://api.mainnet-beta.solana.com";

// Set commitment
let commitment = CommitmentConfig::confirmed();

// Define callback function
let callback = |event: DexEvent| {
    match event {
        DexEvent::NewToken(token_info) => {
            println!("Received new token event: {:?}", token_info);
        },
        DexEvent::NewUserTrade(trade_info) => {
            println!("Received new trade event: {:?}", trade_info);
        },
        DexEvent::NewBotTrade(trade_info) => {
            println!("Received new bot trade event: {:?}", trade_info);
        }
        DexEvent::Error(err) => {
            println!("Received error: {}", err);
        }
    }
};

// Start subscription
let subscription = tokens_subscription(
    ws_url,
    commitment,
    callback,
    None
).await.unwrap();

tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;

// Stop subscription
stop_subscription(subscription).await;

println!("Ended token subscription.");

pumpfun Create, Buy, Sell

use solana_sdk::{
    native_token::LAMPORTS_PER_SOL,
    signature::{Keypair, Signature},
    signer::Signer,
};

use mai3_pumpfun_sdk::{accounts::BondingCurveAccount, utils::CreateTokenMetadata, PriorityFee, PumpFun};

// Create a new PumpFun client
let payer: Keypair = Keypair::new();
let client: PumpFun = PumpFun::new(Cluster::Mainnet, None, &payer, None, None);

// Mint keypair
let mint: Keypair = Keypair::new();

// Token metadata
let metadata: CreateTokenMetadata = CreateTokenMetadata {
    name: "Elon Doge".to_string(),
    symbol: "EDOGE".to_string(),
    description: "Elon Musk Doge".to_string(),
    file: "/path/to/image.png".to_string(),
    twitter: None,
    telegram: None,
    website: Some("https://example.com".to_string()),
};

// Optional priority fee to expedite transaction processing (e.g., 100 LAMPORTS per compute unit, equivalent to a 0.01 SOL priority fee)
let fee: Option<PriorityFee> = Some(PriorityFee {
    limit: Some(100_000),
    price: Some(100_000_000),
});

// Create token with metadata
let signature: Signature = client.create(&mint, metadata.clone(), fee).await?;
println!("Created token: {}", signature);

// Print amount of SOL and LAMPORTS
let amount_sol: u64 = 1;
let amount_lamports: u64 = LAMPORTS_PER_SOL * amount_sol;
println!("Amount in SOL: {}", amount_sol);
println!("Amount in LAMPORTS: {}", amount_lamports);

// Create and buy tokens with metadata
let signature: Signature = client.create_and_buy(&mint, metadata.clone(), amount_lamports, None, fee).await?;
println!("Created and bought tokens: {}", signature);

// Print the curve
let curve: BondingCurveAccount = client.get_bonding_curve_account(&mint.pubkey())?;
println!("{:?}", curve);

// Buy tokens (ATA will be created automatically if needed)
let signature: Signature = client.buy(&mint.pubkey(), amount_lamports, None, fee).await?;
println!("Bought tokens: {}", signature);

// Sell tokens (sell all tokens)
let signature: Signature = client.sell(&mint.pubkey(), None, None, fee).await?;
println!("Sold tokens: {}", signature);