How to stream and parse Pumpswap transactions on Solana

In this article we will explore streaming and parsing pump swap AMM transactions using gRPC

Real-time data is vital for Solana applications tracking dynamic markets like decentralized exchanges. gRPC streaming offers a high-performance way to receive immediate on-chain updates. Previously, Pump.fun tokens migrated to DEXs like Raydium; now, they transition to Pump AMM. Monitoring activity on this new platform requires efficient, low-latency data streaming, making Solana gRPC streaming a crucial tool for real-time observation.

In this article, we will explore how to stream and parse PumpSwap transactions, Pump.fun’s newly introduced AMM.

Before Getting Started

To get started, we will need a few things.

Authentication: gRPC endpoint and gRPC token

Shyft’s gRPC nodes are available in various locations all across EU and the US region. To access, we would require a region-specific gRPC endpoint and an access token, which is available to purchase on your Shyft Dashboard.

A server-side backend (like NodeJS) to receive gRPC data

As gRPC services are unsupported in web-browsers, you would need a backend application such as C#, Go, Java, Python etc. to receive gRPC data.

Introduction

Shyft’s gRPC, utilizing the Geyser framework, provides a live stream of on-chain Solana data, including account updates, transactions, blocks, and slot changes. Our approach involves connecting to Shyft’s gRPC service to create a real-time stream of transactions specifically for PumpSwap AMM.

Get Team Shyft’s stories in your inbox

Join Medium for free to get updates from this writer.

This will allow us to receive transaction data instantly as it’s processed on the blockchain. Our backend will then parse and display this parsed information, which can be used for further processing.

The entire code for this article is available here on GitHub, feel free to clone and follow along.

Initialization — Yellowstone Client

For streaming Pumpfun AMM transactions using gRPC, we need two things: The gRPC endpoint, which is your region-specific endpoint, and a gRPC access token. Both of these are available in your Shyft dashboard. Once you have them, you can initialize the yellowstone client and begin streaming Pumpfun AMM data.

const client = new Client(    'Your Region specific Shyft gRPC URL',    'Shyft gRPC Access Token',    undefined,  );

Now we can proceed to obtain our data from the blockchain.

Specifying what data to receive — Subscribe Request

Once the yellowstone client is set up, the next step is to define exactly what information we want to receive. Shyft’s gRPC interface provides various types of real-time updates, such as account changes, transactions, new blocks, and slot updates. To focus only on the data we need, we have to use “subscribe requests.” Subscribe requests define what data will be streamed. In our case the subscribe request will look something like this.

const req: SubscribeRequest = {  accounts: {},  slots: {},  transactions: {     pumpFun: {      vote: false,      failed: false,      signature: undefined,      accountInclude: [PUMPSWAP_AMM.toBase58()],       accountExclude: [],      accountRequired: [],    },  },  transactionsStatus: {},  entry: {},  blocks: {},  blocksMeta: {},  accountsDataSlice: [],  ping: undefined,  commitment: CommitmentLevel.PROCESSED,   };

The two main aspects of establishing a successful stream are as follows:

• **client**: This is the yellowstone client which is used to connect to the Solana blockchain and subscribe to real-time on-chain events.
• **arg:** This parameter specifies the exact data we want to retrieve from the blockchain by the means of Subscribe Requests.

The handle stream function is responsible for receiving raw transactions from the stream and sending the subscribe request.

async function handleStream(client: Client, args: SubscribeRequest) {        const stream = await client.subscribe();       const streamClosed = new Promise<void>((resolve, reject) => {      stream.on("error", (error) => {        console.log("ERROR", error);        reject(error);        stream.end();      });      stream.on("end", () => {        resolve();      });      stream.on("close", () => {        resolve();      });    });    stream.on("data", async (data) => {      try{     console.log(data);  }catch(error){    if(error){      console.log(error)    }  }});    await new Promise<void>((resolve, reject) => {      stream.write(args, (err: any) => {        if (err === null || err === undefined) {          resolve();        } else {          reject(err);        }      });    }).catch((reason) => {      console.error(reason);      throw reason;    });     await streamClosed;  }

Receiving and parsing transactions

gRPC streams provide transaction data like standard RPC, plus extra fields like isVote, message headers (signature, signer), isVersioned, and block/ping/entry info. Shyft offers a utility function to convert these gRPC transactions to a traditional RPC format.

import { TransactionFormatter } from "./utils/transaction-formatter";const TXN_FORMATTER = new TransactionFormatter();const txn = TXN_FORMATTER.formTransactionFromJson(    data.transaction,    Date.now(),);

The next step involves decoding the transaction, so that the raw data is human readable. That’s where the parsing comes in. We can define our own transaction parser, or simply use Shyft’s Solana transaction parser.

npm i @shyft-to/solana-transaction-parser

This parser just takes in the program IDL, understands how the transaction data is structured, then produces the parsed transaction which can be easily read and understood. In our case, we’ve used Shyft’s parser, which can be initialized in the following manner.

const TXN_FORMATTER = new TransactionFormatter();const PUMP_FUN_AMM_PROGRAM_ID = new PublicKey(  "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA");const PUMP_FUN_IX_PARSER = new SolanaParser([]);PUMP_FUN_IX_PARSER.addParserFromIdl(  PUMP_FUN_AMM_PROGRAM_ID.toBase58(),  pumpFunAmmIdl as Idl);const paredIxs = PUMP_FUN_IX_PARSER.parseTransactionData(   tx.transaction.message,   tx.meta.loadedAddresses);

Conclusion

In summary, establishing a real-time transaction stream for Pump AMM using gRPC, coupled with efficient parsing via Shyft’s transaction parser, provides developers with immediate and understandable insights into the platform’s activity. This is crucial for building responsive applications and gaining a timely understanding of the evolving Pump.fun ecosystem.

In case you missed out, the entire code for this article is available here on GitHub, feel free to clone and follow along.

You can explore our other related articles: Streaming Real-Time Data on Solana, Real-Time Data Streaming with gRPC: Accounts, Transactions, Blocks, How to Stream Real-Time Pump.fun Updates on Solana, and Tracking New Pools on Raydium.

Resources

• SHYFT API & gRPC Documentation
• Shyft Website
• Get API Key
• GitHub
• Join our Discord