> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Buscar Criações de Tokens Pump.fun com Eventos Analisados

> Percorra o histórico de um endereço com Eventos Analisados e extraia as instruções de criação e create_v2 do Pump.fun, registrando cada token emitido com seu criador, nome, símbolo e URI.

Este guia busca **todos os tokens que uma carteira implantou no Pump.fun**. Ele percorre o histórico analisado da carteira e seleciona as duas instruções que o Pump.fun usa para lançar um token, até que o histórico se esgote.

É o equivalente histórico ao guia do Parsed Streams [Acompanhar Criações de Pump.fun](/docs/pt-BR/parsed-streams/guides/track-pumpfun-mints): o mesmo programa, os mesmos nomes de instruções e os mesmos campos decodificados — buscados sob demanda em vez de enviados em tempo real.

<Steps>
  <Step title="Buscar o Programa">
    Pump.fun lança tokens por meio de duas instruções dependendo da versão: `create` e `create_v2`. Eventos Analisados decodificam instruções através do mesmo catálogo IDL usado pelo Parsed Streams, então confirme os nomes exatos decodificados e papéis das contas com seu método [`describeProgram`](/docs/pt-BR/parsed-streams/quickstart#discovery) antes de corresponder a eles:

    ```json Request theme={"system"}
    { "jsonrpc": "2.0", "id": 1, "method": "describeProgram", "params": [{ "program": "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P" }] }
    ```

    Verifique na lista `instructions` da resposta por `create` e `create_v2`, e sua lista `roles` pela conta que você deseja — normalmente o novo endereço **mint**, e um papel 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 tanto um argumento quanto alguns nomes de papel em vez de supor apenas um.
  </Step>

  <Step title="Construir a Solicitação">
    Busque o histórico da carteira do criador página por página:

    ```json theme={"system"}
    {
      "address": "<CREATOR_WALLET>",
      "limit": 100,
      "sortOrder": "desc",
      "commitment": "confirmed"
    }
    ```

    Três diferenças em relação ao filtro de streaming valem ser conhecidas previamente:

    * `address` é sempre exigido — varreduras em todo o programa não são suportadas, então você busca as implantações de uma carteira, não todas as implantações no Pump.fun. Para um fluxo contínuo, use [Parsed Streams](/docs/pt-BR/parsed-streams/guides/track-pumpfun-mints).
    * A solicitação não tem filtro de instrução no lado do servidor. O histórico retorna tudo o que o endereço tocou, e você seleciona as instruções do Pump.fun no lado do cliente no próximo passo.
    * Não há chave de troca `includeFailed`. O histórico retorna transações bem-sucedidas e falhadas, então verifique `parsed.transactionStatus` no lado do cliente — uma implantação falhada nunca produz um mint ativo.
  </Step>

  <Step title="Percorrer o Histórico">
    Cada resultado carrega **todas** as instruções da transação. Verifique `parsed.instructions` em busca de acertos de `create`/`create_v2`, e continue passando `paginationToken` até que desapareça:

    ```javascript pumpfun-mint-history.js theme={"system"}
    const API_KEY = process.env.HELIUS_API_KEY;

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

    const URL = `https://<ENDPOINT>/transaction-history?api-key=${API_KEY}`;
    const PUMP_PROGRAM = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";
    const CREATE_INSTRUCTIONS = ["create", "create_v2"];
    const CREATOR = process.argv[2];

    if (!CREATOR) {
      console.error("Usage: node pumpfun-mint-history.js <CREATOR_WALLET>");
      process.exit(1);
    }

    async function fetchPage(paginationToken) {
      const body = {
        address: CREATOR,
        limit: 100,
        sortOrder: "desc",
        commitment: "confirmed",
      };
      if (paginationToken) body.paginationToken = paginationToken;

      const response = await fetch(URL, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(body),
      });
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
      }
      return response.json();
    }

    async function main() {
      let paginationToken;
      let deployCount = 0;

      do {
        const page = await fetchPage(paginationToken);

        for (const result of page.data) {
          if (result.parserStatus !== "OK") continue;
          // Failed deploys never produce a live mint.
          if (result.parsed.transactionStatus !== "OK") continue;

          for (const ix of result.parsed.instructions) {
            if (ix.programId !== PUMP_PROGRAM) continue;
            if (!CREATE_INSTRUCTIONS.includes(ix.instructionName)) continue;
            deployCount += 1;
            handleDeploy(result, ix, deployCount);
          }
        }

        paginationToken = page.paginationToken;
      } while (paginationToken);

      console.log(`${deployCount} pump deploys found for ${CREATOR}`);
    }

    main();
    ```
  </Step>

  <Step title="Extrair Cada Implantação">
    Extraia o mint, criador e metadados da instrução decodificada, exatamente como o ouvinte de streaming faz:

    ```javascript theme={"system"}
    // 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;
    }

    function handleDeploy(result, ix, deployCount) {
      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(`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=${result.parsed.slot} sig=${result.signature}`);
    }
    ```

    Verifique se `ix.decoded` está presente antes de confiar em `args` e `accounts` — uma versão não reconhecida do programa Pump.fun caso contrário apareceria como `mint: null`, com apenas `rawData` e `rawAccounts` para trabalhar.
  </Step>
</Steps>

## Próximos Passos

<CardGroup cols={2}>
  <Card title="Acompanhar Criações de Pump.fun" icon="rocket" href="/docs/pt-BR/parsed-streams/guides/track-pumpfun-mints">
    A versão em tempo real: um ouvinte seguro contra reconexões que registra cada nova implantação à medida que acontece.
  </Card>
</CardGroup>