Streaming and Parsing Pump.fun Accounts

Real-Time Streaming and Parsing of Pump.fun Transactions Using Solana Yellowstone gRPC and IDL-Based Parsers

For any Solana dApp, trading bots, or real-time analytics platform, efficient account data access is important. Solana gRPC streaming, leveraging technologies like the Geyser plugin and Yellowstone, offers a high-performance, low-latency alternative to traditional RPC calls and WebSockets. In this document, we will explore how we can stream and parse pump.fun account data using Solana Yellowstone gRPCs

The complete source code for this project is available on GitHub.

• TypeScript

• Rust

Please feel free to clone the repository and try it out. Additionally, you will find other relevant and useful code examples related to gRPC and streaming here.

Step-by-Step Breakdown

This project consists of two key components:

1. Streaming Pump.fun Accounts via Yellowstone gRPC

2. Decoding those accounts using the program's IDL

Streaming Accounts Using gRPC

The first step involves initializing the Solana Yellowstone Client. You can get Solana Yellowstone gRPC access from the Shyft Dashboard. Please check out our gRPC Authentication Docs for more details.

Initializing the Client

Once you have the authentication details, you can initialize the client in the following manner,

TypeScript

import Client from "@triton-one/yellowstone-grpc";

const client = new Client(
  "YOUR-GRPC-ENDPOINT", //yellowstone grpc url
  "GRPC-ACCESS-TOKEN", //authentication token
  undefined
);

Rust

use yellowstone_grpc_client::{GeyserGrpcClient, Interceptor}

async fn connect(&self) -> anyhow::Result<GeyserGrpcClient<impl Interceptor>> {
     GeyserGrpcClient::build_from_shared(self.endpoint.clone())? //grpc url
            .x_token(Some(self.x_token.clone()))? //grpc auth token
            .connect_timeout(Duration::from_secs(10))
            .timeout(Duration::from_secs(10))
            .tls_config(ClientTlsConfig::new().with_native_roots())?
            .max_decoding_message_size(1024 * 1024 * 1024)
            .connect()
            .await
            .map_err(Into::into)
}

You can use any Yellowstone gRPC endpoint with this client. An access token is optional, as some gRPC services don't require authentication.

The Rust client supports several additional options, as demonstrated in the example above. Most of these options are also available for the TS client, where they are passed as the third argument to the Client constructor.

Specifying what data to stream from gRPC

To specify what on-chain data, we send a SubscribeRequest over the existing Solana Yellowstone gRPC client. These Request allows you to filter for specific accounts, transactions, slots, or other Solana on-chain events, giving you full control over the data you receive.

SubscribeRequests use filters to determine what type of on-chain data to stream. When streaming account-level data, the account filter plays a crucial role. Specifically, the owner field within the filter allows you to stream data for accounts owned by a particular Solana program.

TypeScript

const req: SubscribeRequest = {
  "slots": {},
  "accounts": {
    "pumpfun": {
      "account": [],
      "filters": [],
      "owner": ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"] // This field indicates 
    }
  },
  "transactions": {},
  "blocks": {},
  "blocksMeta": {},
  "accountsDataSlice": [],
  "commitment": CommitmentLevel.PROCESSED, // Subscribe to processed blocks for the fastest updates
  "entry": {},
  "transactionsStatus": {}
}

Rust

let mut accounts: AccountFilterMap = HashMap::new();

accounts.insert(
    "accountData".to_owned(),
    SubscribeRequestFilterAccounts {
        account: vec![],
        owner: vec!["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"],
        nonempty_txn_signature: None,
        filters: vec![]
    },
);
Ok(SubscribeRequest {
    accounts,
    slots: HashMap::default(),
    transactions: HashMap::default(),
    transactions_status: HashMap::default(),
    blocks: HashMap::default(),
    blocks_meta: HashMap::default(),
    entry: HashMap::default(),
    commitment: Some(CommitmentLevel::Processed as i32),
    accounts_data_slice: Vec::default(),
    ping: None,
    from_slot: None,
})

For example, to stream Pump.fun transaction accounts, you can set the owner field to the Pump.fun program ID. This ensures that only accounts associated with the Pump.fun program are streamed in real-time—ideal for use cases like meme coin trading bots, on-chain analytics, or DeFi dashboards requiring program-specific data.

Once established, the stream will begin sending data directly to your application. You have the flexibility to modify your subscription on the fly, allowing you to change the data specifications you receive without stopping your stream. For more details on reconnecting and re-starting the stream from a specific slot, or closing your gRPC connection, you can find additional information in our documentation.

Decoding the received accounts

As soon as the accounts are updated on chain, the updated account data is sent over the stream. The next step involves decoding the data. For JS/TS, we use BorshAccountCoder from @coral-xyz/anchor to parse the account data in the following manner.

On Rust however, we can use the Solores generated IDL like in our transaction parsing example.

TypeScript

import { BorshAccountsCoder } from "@coral-xyz/anchor";

const program_idl = JSON.parse(fs.readFileSync('./Idl/pump_0.1.0.json', 'utf8'));
const accountCoder = new BorshAccountsCoder(program_idl);

 const decodedData = accountCoder.decodeAny(data.account.account.data);

Rust

use pump_interface::accounts::{BondingCurve, BondingCurveAccount, Global, GlobalAccount, BONDING_CURVE_ACCOUNT_DISCM, GLOBAL_ACCOUNT_DISCM},

pub fn decode_account_data(buf: &[u8]) -> Result<DecodedAccount, AccountDecodeError> {
    if buf.len() < 8 {
        return Err(AccountDecodeError {
            message: "Buffer too short to contain a valid discriminator.".to_string(),
        });
    }

    let discriminator: [u8; 8] = buf[..8].try_into().expect("Failed to extract first 8 bytes");

    match discriminator {
        BONDING_CURVE_ACCOUNT_DISCM => {
            //println!("Bonding Curve Account detected. Proceeding with deserialization...");
            let data = BondingCurveAccount::deserialize(buf)
                .map_err(|e| AccountDecodeError {
                    message: format!("Failed to deserialize BondingCurveAccount: {}", e),
                })?;
            println!("\nDecoded Bonding Curve Structure: {:#?}", data);
            Ok(DecodedAccount::BondingCurve(data.0)) // Unwrapping the inner BondingCurve struct
        }
        GLOBAL_ACCOUNT_DISCM => {
            //println!("Global Account detected. Proceeding with deserialization...");
            let data = GlobalAccount::deserialize(buf)
                .map_err(|e| AccountDecodeError {
                    message: format!("Failed to deserialize GlobalAccount: {}", e),
                })?;
            println!("\nDecoded Global Structure: {:#?}", data);
            Ok(DecodedAccount::Global(data.0)) // Unwrapping the inner Global struct
        }
        _ => Err(AccountDecodeError {
            message: "Account discriminator not found.".to_string(),
        }),
    }
}

Important Links

• Solana gRPC Documentation – In-depth technical docs for implementing real-time streaming with Yellowstone gRPC and Geyser plugin on Solana.
• Blogs on Solana gRPC Streaming – Guides, use cases, and performance benchmarks for building low-latency Solana applications using gRPC-based infrastructure.
• Solana DeFi Code Snippets & Examples – Ready-to-use code snippets and integrations for common DeFi protocols, transaction parsers, and real-time Solana data streaming use cases.