pump-dump 0.1.0

A CLI tool for inspecting Pump.fun pools, events, and transactions on Solana
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use clap::{Parser, Subcommand};
use color_eyre::{Result, eyre::eyre};
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_client::rpc_config::RpcTransactionConfig;
use solana_commitment_config::CommitmentConfig;
use solana_sdk::pubkey::Pubkey;
use solana_transaction_status::UiTransactionEncoding;
use solana_transaction_status::option_serializer::OptionSerializer;
use std::str::FromStr;

mod pump_accounts;
mod pump_events;
mod utils;

use crate::pump_accounts::decode_account;
use crate::pump_events::decode_event;

const BANNER: &str = r#"

            🚀 Pump.fun Pool Inspector & Event Decoder 🚀

 ██████╗ ██╗   ██╗███╗   ███╗██████╗       ██████╗ ██╗   ██╗███╗   ███╗██████╗ 
 ██╔══██╗██║   ██║████╗ ████║██╔══██╗      ██╔══██╗██║   ██║████╗ ████║██╔══██╗
 ██████╔╝██║   ██║██╔████╔██║██████╔╝█████╗██║  ██║██║   ██║██╔████╔██║██████╔╝
 ██╔═══╝ ██║   ██║██║╚██╔╝██║██╔═══╝ ╚════╝██║  ██║██║   ██║██║╚██╔╝██║██╔═══╝ 
 ██║     ╚██████╔╝██║ ╚═╝ ██║██║           ██████╔╝╚██████╔╝██║ ╚═╝ ██║██║     
 ╚═╝      ╚═════╝ ╚═╝     ╚═╝╚═╝           ╚═════╝  ╚═════╝ ╚═╝     ╚═╝╚═╝    "#;

#[derive(Parser)]
#[command(author, version, about = "Pump.fun pool inspector and event decoder", long_about = None)]
#[command(before_help = BANNER)]
struct Cli {
    /// RPC URL for Solana network
    #[arg(
        short = 'u',
        long,
        default_value = "https://api.mainnet-beta.solana.com"
    )]
    rpc_url: String,

    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Decode and display a pump.fun event from base64 data
    Event {
        /// Base64 encoded event data
        data: String,
    },
    /// Fetch and decode account data from Solana address
    Account {
        /// Solana account address (base58)
        address: String,
    },
    /// Fetch transaction and decode pump.fun events from logs
    Tx {
        /// Transaction signature/hash
        signature: String,
    },
}

#[tokio::main]
async fn main() -> Result<()> {
    color_eyre::install()?;

    let cli = Cli::parse();

    let rpc = RpcClient::new_with_commitment(cli.rpc_url.clone(), CommitmentConfig::confirmed());

    match cli.command {
        Commands::Event { data } => {
            println!("🔍 Decoding pump.fun event...\n");

            let event = decode_event(&data).map_err(|e| eyre!("Failed to decode event: {}", e))?;

            println!("{}", event);
        }

        Commands::Account { address } => {
            println!("📡 Fetching account data from {}\n", cli.rpc_url);

            let pubkey = Pubkey::from_str(&address)
                .map_err(|e| eyre!("Invalid account address '{}': {}", address, e))?;

            let account_data = rpc
                .get_account_data(&pubkey)
                .await
                .map_err(|e| eyre!("Failed to fetch account data: {}", e))?;

            let account = decode_account(&account_data)
                .map_err(|e| eyre!("Failed to decode account data: {}", e))?;

            println!("{}", account);
        }

        Commands::Tx { signature } => {
            println!(
                "🔗 Fetching transaction {} from {}\n",
                signature, cli.rpc_url
            );

            let sig = signature
                .parse()
                .map_err(|e| eyre!("Invalid transaction signature '{}': {}", signature, e))?;

            let transaction = rpc
                .get_transaction_with_config(
                    &sig,
                    RpcTransactionConfig {
                        encoding: Some(UiTransactionEncoding::Json),
                        commitment: Some(CommitmentConfig::confirmed()),
                        max_supported_transaction_version: Some(0),
                    },
                )
                .await
                .map_err(|e| eyre!("Failed to fetch transaction: {}", e))?;

            // Extract and process logs
            if let Some(meta) = transaction.transaction.meta {
                if let OptionSerializer::Some(logs) = meta.log_messages {
                    let mut found_events = false;

                    for log in &logs {
                        // Look for "Program data: " prefix in logs
                        if let Some(data_start) = log.find("Program data: ") {
                            let base64_data = &log[data_start + 14..];

                            // Try to decode as pump.fun event
                            if let Ok(event) = decode_event(base64_data) {
                                if !found_events {
                                    println!("📊 Found pump.fun events:");
                                    found_events = true;
                                }
                                println!("{}", event);
                            }
                        }
                    }

                    if !found_events {
                        println!("ℹī¸  No pump.fun events found in transaction logs");

                        // Show raw logs for debugging
                        println!("\n📜 Transaction logs:");
                        for (i, log) in logs.iter().enumerate() {
                            println!("{:2}: {}", i + 1, log);
                        }
                    }
                } else {
                    println!("⚠ī¸  No logs found in transaction");
                }
            } else {
                println!("⚠ī¸  No transaction metadata available");
            }
        }
    }

    Ok(())
}