Detecting new Token launches on Pump.fun
Leveraging Solana Yellowstone gRPC for Ultra-Low Latency New Pump.fun Token Alerts
Monitoring the Pump.AMM for new token launches demands real-time, low-latency data access. This guide demonstrates how to leverage Solana's Yellowstone gRPC stream to efficiently detect newly minted token addresses, providing instant insights into emerging Solana memecoins and trading opportunities.
The complete source code for this project is available on GitHub.
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:
Streaming Pump.fun Transactions via Yellowstone gRPC
Parsing the Received transactions
Identifying new tokens based on the parsed transaction data
Streaming Transactions 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,
import Client from "@triton-one/yellowstone-grpc";
const client = new Client(
"YOUR-GRPC-ENDPOINT", //yellowstone grpc url
"GRPC-ACCESS-TOKEN", //authentication token
undefined
);
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. You can find out more about Subscribe Requests here.
Subscribe Requests specify what data to stream by the means of filters. When you want to stream transactions, you use a transaction filter. Inside this filter, you tell it which program's transactions you're interested in by providing its "program ID" in the "account" field. The example below demonstrates how to initiate a gRPC stream by sending a SubscribeRequest
using a standard gRPC client:
const req: SubscribeRequest = {
accounts: {},
slots: {},
transactions: {
pumpFun: {
vote: false,
failed: false,
signature: undefined,
accountInclude: ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"],
//for our usecase we only need to listen to transaction belonging to one program, so we have added one address
accountExclude: [],
accountRequired: [],
},
},
transactionsStatus: {},
entry: {},
blocks: {},
blocksMeta: {},
accountsDataSlice: [],
ping: undefined,
commitment: CommitmentLevel.CONFIRMED,
};
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.
Parsing the received transaction
Once a raw Solana transaction is received via the Yellowstone gRPC stream, it must be parsed to extract meaningful, human-readable data. For JavaScript/TypeScript applications, we use Shyft's IDL-based transaction parser, which decodes the transactions received from the gRPC into structured data based on the respective program's IDL. On Rust however, we use a interface generated by solores to parse the transaction instruction.
import { SolanaParser } from "@shyft-to/solana-transaction-parser";
const PUMP_FUN_IX_PARSER = new SolanaParser([]);
//initializing the parser
PUMP_FUN_IX_PARSER.addParserFromIdl(
PUMP_FUN_PROGRAM_ID .toBase58(),
pumpFunAmmIdl as Idl
);
const PUMP_FUN_EVENT_PARSER = new SolanaEventParser([], console);
PUMP_FUN_EVENT_PARSER.addParserFromIdl(
PUMP_FUN_PROGRAM_ID .toBase58(),
pumpFunAmmIdl as Idl
);
//adding pump.fun idl for parsing pumpfun transactions
function decodePumpFunTxn(tx: VersionedTransactionResponse) {
if (tx.meta?.err) return;
try{
const paredIxs = PUMP_FUN_IX_PARSER.parseTransactionData(
tx.transaction.message,
tx.meta.loadedAddresses,
); //parsing transaction
const pumpFunIxs = paredIxs.filter((ix) =>
ix.programId.equals(PUMP_FUN_PROGRAM_ID) || ix.programId.equals(new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")),
);
const parsedInnerIxs = PUMP_FUN_IX_PARSER.parseTransactionWithInnerInstructions(tx);
const pumpfun_amm_inner_ixs = parsedInnerIxs.filter((ix) =>
ix.programId.equals(PUMP_FUN_PROGRAM_ID) || ix.programId.equals(new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")),
); //parsing inner instructions
if (pumpFunIxs.length === 0) return;
const events = PUMP_FUN_EVENT_PARSER.parseEvent(tx);
const result = { instructions: pumpFunIxs, inner_ixs: pumpfun_amm_inner_ixs, events };
return result;
}catch(err){
console.log(err);
}
}
Detecting New Tokens
Once the transaction is parsed, we extract the newly minted token's address (Ca) by navigating to result.meta.postTokenBalances[0].mint
. This Ca
value, representing the newly launched memecoin, is then immediately logged, providing real-time alerts for Pump.fun token launches.
stream.on("data", async (data) => {
try{
const result = await tOutPut(data);
const Ca = result.meta.postTokenBalances[0].mint
console.log(`
NEWLY MINTED
Ca : ${Ca}
`)
} catch(error) {
//handle error
}
});
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.
Last updated
Was this helpful?