Pump.fun-Token-Mints mit Parsed Streams verfolgen

Dieser Leitfaden erstellt einen dauerhaft laufenden Listener für jeden neuen Pump.fun-Token. Er filtert nach den beiden Instructions, mit denen Pump.fun einen Token veröffentlicht. Er bleibt auch dann verbunden, wenn wegen Inaktivität ein timeout auftritt oder ein neues deployment erfolgt.

Look Up the Program

Pump.fun veröffentlicht token je nach Version über zwei Instruktionen: create und create_v2. Prüfe die genauen Namen und Kontorollen mit describeProgram, bevor du danach filterst. Aktuell ist es nur auf wss://fs-beta.helius-rpc.com/?api-key=<API_KEY> verfügbar:

Request

{ "jsonrpc": "2.0", "id": 1, "method": "describeProgram", "params": [{ "program": "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P" }] }

Prüfe in der response die Liste instructions auf create und create_v2. Prüfe außerdem in der Liste roles den gewünschten Account – normalerweise die neue mint-Adresse sowie entweder die Account-Rolle creator oder das Feld creator in args. Die beiden Instruction-Versionen haben nicht zwingend dieselbe Struktur. Deshalb prüft der folgende Code sowohl ein Argument als auch mehrere Rollennamen, statt eine einheitliche Struktur vorauszusetzen.

Build the Filter

Filtere nach dem Programm und beiden Instruction-Namen. Lass includeCpi aktiviert. Die Instructions create/create_v2 von Pump.fun befinden sich normalerweise auf der obersten Ebene, aber diese zusätzliche Absicherung ist günstig. Schließe außerdem fehlgeschlagene Transaktionen aus, da ein fehlgeschlagenes deployment nie einen aktiven mint erzeugt:

{
  "programs": ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"],
  "instructionNames": ["create", "create_v2"],
  "includeFailed": false,
  "includeCpi": true
}

Connect with a Reconnect-Safe Client

Ein Tracker für veröffentlichte Token läuft dauerhaft. Behandle Verbindungsabbrüche daher als normal und nicht als Ausnahme: Überwache den ersten Handshake mit einem Watchdog, halte die Verbindung bei einem inaktiven Filter aktiv und stelle sie nach dem Schließen automatisch wieder her.

pumpfun-deploys.js

const API_KEY = process.env.HELIUS_API_KEY;

if (!API_KEY) {
  console.error("Missing HELIUS_API_KEY.");
  process.exit(1);
}

const URL = `wss://beta.helius-rpc.com/?api-key=${API_KEY}`;
const PUMP_PROGRAM = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";

const SUBSCRIBE_ID = 1;
const SUBSCRIBE_REQUEST = {
  jsonrpc: "2.0",
  id: SUBSCRIBE_ID,
  method: "parsedTransactionSubscribe",
  params: [
    {
      programs: [PUMP_PROGRAM],
      instructionNames: ["create", "create_v2"],
      includeFailed: false,
      includeCpi: true,
    },
  ],
};

const CONNECT_TIMEOUT_MS = 10_000;

const ts = () => new Date().toISOString();

function connect() {
  console.log(`[${ts()}] connecting…`);
  const ws = new WebSocket(URL);

  // Watchdog: if the handshake never completes, force-close so we retry
  // instead of hanging silently in CONNECTING.
  const connectTimer = setTimeout(() => {
    if (ws.readyState === WebSocket.CONNECTING) {
      console.error(`[${ts()}] handshake stalled after ${CONNECT_TIMEOUT_MS}ms — closing`);
      ws.close();
    }
  }, CONNECT_TIMEOUT_MS);

  ws.addEventListener("open", () => {
    clearTimeout(connectTimer);
    console.log(`[${ts()}] connected, subscribing to pump create/create_v2`);
    ws.send(JSON.stringify(SUBSCRIBE_REQUEST));
  });

  ws.addEventListener("message", (event) => handleMessage(event.data));

  ws.addEventListener("error", (err) => {
    console.error(`[${ts()}] socket error:`, err.message || err);
  });

  ws.addEventListener("close", (event) => {
    clearTimeout(connectTimer);
    console.log(`[${ts()}] closed (code=${event.code}, reason="${event.reason}"). reconnecting in 3s…`);
    setTimeout(connect, 3000);
  });
}

connect();

Hier wird der Einfachheit halber eine feste Verzögerung von 3 Sekunden vor dem reconnect verwendet. Nutze für einen produktiven Listener stattdessen exponentielles Backoff – siehe Umgang mit erneuten Verbindungen.

Handle Notifications and Log Each Deploy

Leite eingehende Nachrichten anhand von id (request von dir) oder method (vom Server gesendete Benachrichtigungen) weiter. Lies dann mint, Ersteller und Metadaten aus der decodierten Instruction aus:

// Pull an account pubkey out of a decoded instruction by its role name.
function accountByRole(decoded, role) {
  return decoded?.accounts?.find((a) => a.name === role)?.pubkey ?? null;
}

let deployCount = 0;

function handleDeploy(tx, ix) {
  deployCount += 1;
  const args = ix.decoded?.args ?? {};
  const mint = accountByRole(ix.decoded, "mint");
  const creator =
    args.creator ??
    accountByRole(ix.decoded, "creator") ??
    accountByRole(ix.decoded, "user");

  console.log(`[${ts()}] pump deploy #${deployCount} (${ix.instructionName})`);
  console.log(`    mint:    ${mint}`);
  console.log(`    creator: ${creator}`);
  console.log(`    name:    ${args.name ?? "?"}`);
  console.log(`    symbol:  ${args.symbol ?? "?"}`);
  console.log(`    uri:     ${args.uri ?? "?"}`);
  console.log(`    slot=${tx.slot} sig=${tx.signature}`);
}

function handleMessage(raw) {
  let msg;
  try {
    msg = JSON.parse(raw);
  } catch {
    console.log(`[${ts()}] non-JSON message:`, raw);
    return;
  }

  if (msg.error) {
    console.error(`[${ts()}] error (code=${msg.error.code}): ${msg.error.message}`);
    return;
  }
  if (msg.id === SUBSCRIBE_ID && typeof msg.result === "number") {
    console.log(`[${ts()}] subscribed (subscription id=${msg.result})`);
    return;
  }

  if (msg.method === "parsedTransactionNotification") {
    const { value } = msg.params.result;
    // Default details is "full", so value.instructions is the whole
    // transaction; matchedIndexes points at just the create/create_v2
    // instructions this filter hit.
    for (const i of value.matchedIndexes) handleDeploy(value.transaction, value.instructions[i]);
    return;
  }

  console.log(`[${ts()}] message:`, JSON.stringify(msg, null, 2));
}

Da includeFailed den Wert false hat, gehört jede protokollierte Benachrichtigung zu einem Token, dessen deployment tatsächlich erfolgreich war. Prüfe, ob ix.decoded vorhanden ist, bevor du dich auf args und accounts verlässt. Ein nicht erkannter Build des Pump.fun-Programms wird mit decoded: null geliefert und würde sonst als mint: null erscheinen.

Nächste Schritte

Track Jupiter Swaps

Der Ablauf describeProgram → Filter erstellen → abonnieren im Detail.

Handling Reconnects

Exponentielles Backoff und backfill für fehlende slot bei dauerhaft laufenden Listenern.

Fetch Pump.fun Mints

Die historische Variante: Rufe mit Parsed Events die früheren Token-Veröffentlichungen eines Erstellers seitenweise ab.

Hier starten

Echtzeitdaten

Trading mit niedriger Latenz

Historische Daten und Wallet-Daten

Anleitungen zu RPC-Methoden

Produktionsreife

Orb verwenden

Weitere Anleitungen

Pump.fun-Token-Mints mit Parsed Streams verfolgen

Nächste Schritte

Track Jupiter Swaps

Handling Reconnects

Fetch Pump.fun Mints

​Nächste Schritte

Track Jupiter Swaps

Handling Reconnects

Fetch Pump.fun Mints

Nächste Schritte