> ## 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.

# Obtén los mints de tokens de Pump.fun con eventos analizados

> Recorre por páginas el historial de una dirección de Solana con los eventos analizados de Helius y extrae las instrucciones de creación de Pump.fun: mint del token, creador, nombre, símbolo y URI.

Esta guía obtiene **todos los tokens que una billetera ha desplegado en Pump.fun**. Recorre por páginas el historial analizado de la billetera y selecciona las dos instrucciones que Pump.fun usa para lanzar un token hasta agotar el historial.

Es el equivalente histórico de la guía de flujos analizados [Rastrear mints de Pump.fun](/docs/es/parsed-streams/guides/track-pumpfun-mints): el mismo programa, los mismos nombres de instrucciones y los mismos campos decodificados, obtenidos bajo demanda en lugar de enviarse en tiempo real.

<Steps>
  <Step title="Look Up the Program">
    Pump.fun lanza tokens mediante dos instrucciones según la versión: `create` e `create_v2`. Los eventos analizados decodifican las instrucciones mediante el mismo catálogo IDL que usan los flujos analizados, así que confirma los nombres decodificados exactos y los roles de las cuentas con su método [`describeProgram`](/docs/es/parsed-streams/quickstart#descubrimiento) antes de buscar coincidencias:

    ```json Request theme={"system"}
    { "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, normalmente la nueva dirección de **mint**, y un rol 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 código siguiente comprueba tanto un argumento como un par de nombres de roles, en lugar de asumir una sola estructura.
  </Step>

  <Step title="Build the Request">
    Obtén el historial de la billetera del creador página por página:

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

    Conviene conocer de antemano tres diferencias respecto del filtro de streaming:

    * `address` siempre es obligatorio. No se admiten búsquedas en todo el programa, así que obtienes los despliegues de una sola billetera, no todos los despliegues de Pump.fun. Para recibir el flujo completo, usa [Flujos analizados](/docs/es/parsed-streams/guides/track-pumpfun-mints).
    * La solicitud no incluye un filtro de instrucciones del lado del servidor. El historial devuelve todo aquello con lo que interactuó la dirección, y tú seleccionas las instrucciones de Pump.fun del lado del cliente en el paso siguiente.
    * No existe el selector `includeFailed`. El historial devuelve tanto las transacciones exitosas como las fallidas, así que comprueba `parsed.transactionStatus` del lado del cliente. Un despliegue fallido nunca produce un mint activo.
  </Step>

  <Step title="Page Through History">
    Cada resultado contiene **todas** las instrucciones de la transacción. Examina `parsed.instructions` para encontrar coincidencias con `create`/`create_v2` y sigue enviando `paginationToken` hasta que desaparezca:

    ```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://mainnet.helius-rpc.com/v1/parsed-events/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="Extract Each Deploy">
    Extrae el mint, el creador y los metadatos de la instrucción decodificada, igual que lo hace el listener de streaming:

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

    Comprueba que `ix.decoded` esté presente antes de confiar en `args` e `accounts`. De lo contrario, una compilación no reconocida del programa Pump.fun aparecería como `mint: null` y solo tendrías `rawData` e `rawAccounts` con los que trabajar.
  </Step>
</Steps>

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Track Pump.fun Mints" icon="rocket" href="/docs/es/parsed-streams/guides/track-pumpfun-mints">
    La versión en tiempo real: un listener resistente a las reconexiones que registra cada nuevo despliegue cuando llega.
  </Card>
</CardGroup>