pumpfun 4.6.0

Rust SDK to interact with the Pump.fun Solana program.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::{
    fs,
    sync::{Arc, Mutex, MutexGuard, OnceLock},
};

use pumpfun::{
    common::types::{Cluster, PriorityFee},
    PumpFun,
};
use solana_sdk::{
    commitment_config::CommitmentConfig,
    signature::{read_keypair_file, Keypair},
};

// Load the default keypair with error handling
fn load_default_keypair() -> Result<Keypair, String> {
    // Get home directory in a cross-platform way
    let home_path = dirs::home_dir().ok_or("Could not determine home directory")?;
    let default_keypair_path = home_path.join(".config/solana/id.json");

    // Check if the keypair file exists
    if !default_keypair_path.exists() {
        // Generate a new keypair
        let keypair = Keypair::new();

        // Create directory if it doesn't exist
        if let Some(parent) = default_keypair_path.parent() {
            fs::create_dir_all(parent)
                .map_err(|e| format!("Failed to create directory {}: {}", parent.display(), e))?;
        }

        // Write the keypair to file
        let keypair_bytes = keypair.to_bytes();
        fs::write(&default_keypair_path, keypair_bytes).map_err(|e| {
            format!(
                "Failed to write keypair to {}: {}",
                default_keypair_path.display(),
                e
            )
        })?;

        return Ok(keypair);
    }

    // Read existing keypair
    read_keypair_file(&default_keypair_path).map_err(|e| {
        format!(
            "Failed to read keypair from {}: {}",
            default_keypair_path.display(),
            e
        )
    })
}

// Global state with OnceLock
static DEFAULT_KEYPAIR: OnceLock<Keypair> = OnceLock::new();
static PAYER: OnceLock<Arc<Keypair>> = OnceLock::new();
static MINT: OnceLock<Arc<Keypair>> = OnceLock::new();
static CLIENT: OnceLock<Mutex<PumpFun>> = OnceLock::new();

// Initialize global state
fn initialize_globals() {
    // Load and set the default keypair
    let keypair = load_default_keypair().expect("Failed to load default keypair");
    DEFAULT_KEYPAIR
        .set(keypair)
        .expect("DEFAULT_KEYPAIR already set");

    // Set payer and mint keypairs
    PAYER
        .set(Arc::new(DEFAULT_KEYPAIR.get().unwrap().insecure_clone()))
        .expect("PAYER already set");
    MINT.set(Arc::new(Keypair::from_base58_string(
        "2Cc5p7aNW8jsTbDxmPMfguDxwrDFWUu1s93gABJYTUJ2xGLF9w2EpPCW1CGFvKYAWzuHXh5fLhrmroHjd8LwBQxj",
    )))
    .expect("MINT already set");

    // Initialize the PumpFun client with configurable cluster URLs
    CLIENT
        .set(Mutex::new(PumpFun::new(
            PAYER.get().unwrap().clone(),
            if std::env::var("SKIP_EXPENSIVE_TESTS").is_ok() {
                Cluster::mainnet(CommitmentConfig::finalized(), PriorityFee::default())
            } else {
                Cluster::localnet(CommitmentConfig::finalized(), PriorityFee::default())
            },
        )))
        .unwrap_or_else(|_| panic!("CLIENT already set"));
}

pub struct TestContext {
    pub payer: Arc<Keypair>,
    pub mint: Arc<Keypair>,
    pub client: MutexGuard<'static, PumpFun>,
}

impl Default for TestContext {
    fn default() -> Self {
        // Ensure globals are initialized
        if DEFAULT_KEYPAIR.get().is_none() {
            initialize_globals();
        }

        Self {
            payer: PAYER.get().unwrap().clone(),
            mint: MINT.get().unwrap().clone(),
            client: CLIENT
                .get()
                .unwrap()
                .lock()
                .expect("Failed to lock CLIENT mutex"),
        }
    }
}