Rastrea acuñaciones de tokens de Pump.fun con Parsed Streams

Esta guía crea un listener de larga duración para cada nuevo token de Pump.fun. Filtra las dos instrucciones que Pump.fun usa para lanzar un token y mantiene la conexión durante tiempos de espera por inactividad e implementaciones.

Look Up the Program

Pump.fun lanza tokens mediante dos instrucciones, según la versión: create e create_v2. Confirma los nombres exactos y las funciones de las cuentas con describeProgram antes de filtrarlas:

Request

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

Revisa la lista instructions de la respuesta para encontrar create e create_v2, y su lista roles para encontrar la cuenta que buscas. Por lo general, será la nueva dirección de mint y una función de cuenta creator o un campo creator en args. Las dos versiones de la instrucción no necesariamente tienen la misma estructura. Por eso, el siguiente código comprueba tanto un argumento como un par de nombres de funciones, en lugar de asumir una sola estructura.

Build the Filter

Filtra por el programa y por ambos nombres de instrucciones. Mantén activado includeCpi. Las instrucciones create/create_v2 de Pump.fun suelen estar en el nivel superior, pero esta es una precaución de bajo costo. Excluye también las transacciones fallidas, ya que una implementación fallida nunca produce un mint activo:

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

Connect with a Reconnect-Safe Client

Un rastreador de implementaciones es un proceso de larga duración. Por eso, trata las desconexiones como algo habitual, no excepcional: supervisa la conexión inicial, mantén activa la conexión cuando el filtro no genere actividad y vuelve a conectarte automáticamente cuando se cierre.

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();

Para simplificar, esto usa un retraso fijo de 3 segundos antes de volver a conectarse. Para un listener de producción, usa una espera exponencial; consulta Manejo de reconexiones.

Handle Notifications and Log Each Deploy

Enruta los mensajes entrantes mediante id (tus propias solicitudes) o method (notificaciones enviadas por el servidor). Luego, extrae el mint, el creador y los metadatos de la instrucción decodificada:

// 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));
}

Como includeFailed es false, cada notificación que registras corresponde a un token que realmente se implementó. Comprueba que ix.decoded esté presente antes de confiar en args e accounts. Una compilación no reconocida del programa Pump.fun llega con decoded: null y, de lo contrario, aparecería como mint: null.

Próximos pasos

Track Jupiter Swaps

El flujo describeProgram → crear filtro → suscribirse con más detalle.

Handling Reconnects

Espera exponencial y relleno de intervalos de slots para listeners de larga duración.

Fetch Pump.fun Mints

La versión histórica: recorre por páginas las implementaciones anteriores de un creador con Parsed Events.

Comienza aquí

Datos en tiempo real

Trading de baja latencia

Datos históricos y de billeteras

Guías de métodos RPC

Preparación para producción

Uso de Orb

Otras guías prácticas

Rastrea acuñaciones de tokens de Pump.fun con Parsed Streams

Próximos pasos

Track Jupiter Swaps

Handling Reconnects

Fetch Pump.fun Mints

​Próximos pasos

Track Jupiter Swaps

Handling Reconnects

Fetch Pump.fun Mints

Próximos pasos