Acompanhar Mints de Tokens Pump.fun com Parsed Streams

Este guia constrói um listener de longa duração para cada novo token Pump.fun. Ele filtra as duas instruções que o Pump.fun usa para lançar um token e permanece conectado durante os timeouts ociosos e implantações.

Localizar o Programa

O Pump.fun lança tokens através de duas instruções dependendo da versão: create e create_v2. Confirme os nomes exatos e funções das contas com describeProgram antes de filtrá-los:

Request

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

Verifique a lista instructions da resposta para create e create_v2, e sua lista roles para a conta desejada — tipicamente o novo endereço de mint, e seja uma função de conta creator ou um campo creator em args. As duas versões de instrução não necessariamente compartilham uma forma, por isso o código abaixo verifica ambos um argumento e alguns nomes de função em vez de assumir um único formato.

Construir o Filtro

Filtre no programa e ambos os nomes de instrução. Deixe includeCpi ativado — create/create_v2 do Pump.fun geralmente são de nível superior, mas isso é uma garantia barata — e exclua transações com falha, já que uma implantação com falha nunca produz um mint ativo:

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

Conectar com um Cliente Seguro para Reconexão

Um rastreador de implantação é um processo de longa duração, portanto trate desconexões como rotina em vez de excepcional: monitore o handshake inicial, mantenha a conexão ativa em um filtro silencioso e reconecte automaticamente ao fechar.

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

Isto usa um atraso fixo de reconexão de 3 segundos para simplicidade. Para um listener de produção, retroceda exponencialmente — veja Tratando Reconexões.

Tratar Notificações e Registrar Cada Implantação

Direcione mensagens recebidas por id (suas próprias solicitações) ou method (notificações enviadas pelo servidor), então extraia o mint, criador e metadados da instrução 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));
}

Porque includeFailed é false, cada notificação que você registra é um token que foi realmente implantado. Verifique se ix.decoded está presente antes de confiar em args e accounts — uma compilação não reconhecida do programa Pump.fun chega com decoded: null e de outra forma apareceria como mint: null.

Próximos Passos

Acompanhar Swaps do Jupiter

O fluxo descreverPrograma → construir filtro → assinar em mais detalhes.

Tratando Reconexões

Retrocesso exponencial e preenchimento de lacunas de slot para ouvintes de longa duração.

Buscar Mints Pump.fun

A versão histórica: percorra as implantações passadas de um criador com Eventos Analisados.

Primeiros Passos

Transmissão de Dados e Audição de Eventos

APIs de Dados & RPCs

Negociação

Enviando Transações

Carteira como Serviço

Privacidade

Recursos

Acompanhar Mints de Tokens Pump.fun com Parsed Streams

Próximos Passos

Acompanhar Swaps do Jupiter

Tratando Reconexões

Buscar Mints Pump.fun

​Próximos Passos

Acompanhar Swaps do Jupiter

Tratando Reconexões

Buscar Mints Pump.fun

Próximos Passos