Verfolgen Sie Pump.fun Token-Mints mit Parsed Streams

Dieser Leitfaden erstellt einen lang laufenden Listener für jedes neue Pump.fun-Token. Er filtert die zwei Anweisungen, die Pump.fun zum Starten eines Tokens verwendet, und bleibt während Leerlauf-Timeouts und Bereitstellungen verbunden.

Programm nachschlagen

Pump.fun startet Tokens durch zwei Anweisungen, abhängig von der Version: create und create_v2. Bestätigen Sie die genauen Namen und Kontenrollen mit describeProgram, bevor Sie darauf filtern:

Request

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

Überprüfen Sie die instructions-Liste der Antwort auf create und create_v2 und ihre roles-Liste auf das Konto, das Sie wünschen — typischerweise die neue Mint-Adresse und entweder eine creator Kontorolle oder ein creator Feld in args. Die beiden Anweisungsversionen teilen sich nicht unbedingt eine Form, weshalb der Code unten sowohl ein Argument als auch ein paar Rollennamen überprüft, anstatt eine anzunehmen.

Filter erstellen

Filtern Sie nach dem Programm und beiden Anweisungsnamen. Lassen Sie includeCpi an — Pump.fun’s create/create_v2 sind normalerweise auf oberster Ebene, aber dies ist eine günstige Versicherung — und schließen Sie fehlgeschlagene Transaktionen aus, da eine fehlgeschlagene Bereitstellung nie ein Live-Mint produziert:

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

Mit einem Reconnect-sicheren Client verbinden

Ein Bereitstellungs-Tracker ist ein lang laufender Prozess, behandeln Sie daher Unterbrechungen als Routine statt als Ausnahme: Überwachen Sie den initialen Handshake, halten Sie die Verbindung bei einem leisen Filter am Leben und stellen Sie bei Schließen automatisch eine erneute Verbindung 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://fs-beta.helius-rpc.com/?api-key=${API_KEY}`;
const PUMP_PROGRAM = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";

const SUBSCRIBE_ID = 1;
const PING_ID = 99;
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 PING_INTERVAL_MS = 30_000; // server closes idle connections after 10 min

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

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

  // 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));
    pingTimer = setInterval(() => {
      if (ws.readyState === WebSocket.OPEN) {
        ws.send(JSON.stringify({ jsonrpc: "2.0", id: PING_ID, method: "ping" }));
      }
    }, PING_INTERVAL_MS);
  });

  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);
    if (pingTimer) clearInterval(pingTimer);
    console.log(`[${ts()}] closed (code=${event.code}, reason="${event.reason}"). reconnecting in 3s…`);
    setTimeout(connect, 3000);
  });
}

connect();

Dies verwendet eine feste Wiederverzögerung von 3 Sekunden zur Vereinfachung. Für einen Produktions-Listener sollten Sie stattdessen exponentiell zurückgehen — siehe Handling Reconnects.

Benachrichtigungen verarbeiten und jede Bereitstellung protokollieren

Routen Sie eingehende Nachrichten nach id (Ihre eigenen Anfragen) oder method (server-gesendete Benachrichtigungen), ziehen Sie dann das Mint, den Ersteller und die Metadaten aus der dekodierten Anweisung:

// 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.id === PING_ID) return; // keepalive pong, ignore quietly

  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 false ist, ist jede Benachrichtigung, die Sie protokollieren, ein Token, das tatsächlich bereitgestellt wurde. Überprüfen Sie, ob ix.decoded vorhanden ist, bevor Sie args und accounts vertrauen — ein nicht erkanntes Build des Pump.fun-Programms kommt mit decoded: null und würde sonst als mint: null angezeigt.

Nächste Schritte

Jupiter Swaps verfolgen

Der Beschreibe-Programm-→-Filter-erstellen-→-Abonnieren-Ablauf im Detail.

Handling Reconnects

Exponentieller Backoff und Slot-Gap-Backfill für lang laufende Listener.

Pump.fun Mints abrufen

Die historische Version: Blättern Sie durch die vergangenen Bereitstellungen eines Erstellers mit Parsed Events.

Hier starten

Echtzeitdaten

Niedrig-Latenz-Handel

Historische & Wallet-Daten

RPC-Methodenanleitungen

Produktionsbereitschaft

Orb verwenden

Weitere Anleitungen

Verfolgen Sie Pump.fun Token-Mints mit Parsed Streams

Nächste Schritte

Jupiter Swaps verfolgen

Handling Reconnects

Pump.fun Mints abrufen

​Nächste Schritte

Jupiter Swaps verfolgen

Handling Reconnects

Pump.fun Mints abrufen

Nächste Schritte