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

# Récupérer les Mint Tokens Pump.fun avec des Événements Analysés

> Parcourez l'historique d'une adresse Solana avec Helius Parsed Events et extrayez les instructions de création Pump.fun — mint de token, créateur, nom, symbole, et URI.

Ce guide récupère **chaque token déployé par un portefeuille sur Pump.fun**. Il parcourt l'historique analysé du portefeuille et sélectionne les deux instructions utilisées par Pump.fun pour lancer un token, jusqu'à épuisement de l'historique.

C'est le pendant historique du guide Parsed Streams [Suivre les Mints Pump.fun](/docs/fr/parsed-streams/guides/track-pumpfun-mints) : même programme, mêmes noms d'instructions, et mêmes champs décodés — récupérés sur demande au lieu d'être poussés en temps réel.

<Steps>
  <Step title="Rechercher le Programme">
    Pump.fun lance les tokens via deux instructions selon la version : `create` et `create_v2`. Parsed Events décode les instructions à travers le même catalogue IDL que celui utilisé par Parsed Streams, alors confirmez les noms décodés exacts et les rôles de compte avec sa méthode [`describeProgram`](/docs/fr/parsed-streams/quickstart#découverte) avant de les faire correspondre :

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

    Vérifiez la liste `instructions` de la réponse pour `create` et `create_v2`, et sa liste `roles` pour le compte souhaité — généralement la nouvelle adresse de **mint**, et soit un rôle de compte `creator` soit un champ `creator` dans `args`. Les deux versions d'instruction ne partagent pas nécessairement une forme, c'est pourquoi le code ci-dessous vérifie à la fois un argument et quelques noms de rôles plutôt que d'en supposer un seul.
  </Step>

  <Step title="Construire la Requête">
    Récupérez l'historique du portefeuille créateur page par page :

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

    Trois différences par rapport au filtre de streaming sont à connaître au préalable :

    * `address` est toujours requis — les analyses à l'échelle du programme ne sont pas prises en charge, vous récupérez donc les déploiements d'un portefeuille, pas chaque déploiement sur Pump.fun. Pour le firehose, utilisez [Parsed Streams](/docs/fr/parsed-streams/guides/track-pumpfun-mints).
    * La requête n'a pas de filtre d'instruction côté serveur. L'historique renvoie tout ce que l'adresse a touché, et vous sélectionnez les instructions Pump.fun côté client à l'étape suivante.
    * Il n'y a pas de commutateur `includeFailed`. L'historique renvoie les transactions réussies et échouées, alors vérifiez `parsed.transactionStatus` côté client — un déploiement échoué ne produit jamais un mint actif.
  </Step>

  <Step title="Parcourir l'Historique">
    Chaque résultat porte **toutes** les instructions de la transaction. Analysez `parsed.instructions` pour les résultats `create`/`create_v2`, et continuez à renvoyer `paginationToken` jusqu'à ce qu'il disparaisse :

    ```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="Extraire Chaque Déploiement">
    Extrayez le mint, le créateur, et les métadonnées de l'instruction décodée, exactement comme le fait l'écouteur 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}`);
    }
    ```

    Vérifiez que `ix.decoded` est présent avant de faire confiance à `args` et `accounts` — une version non reconnue du programme Pump.fun apparaîtrait autrement comme `mint: null`, avec seulement `rawData` et `rawAccounts` avec lesquelles travailler.
  </Step>
</Steps>

## Prochaines Étapes

<CardGroup cols={2}>
  <Card title="Suivre les Mints Pump.fun" icon="rocket" href="/docs/fr/parsed-streams/guides/track-pumpfun-mints">
    La version en temps réel : un écouteur sûr pour la reconnexion qui enregistre chaque nouveau déploiement à son arrivée.
  </Card>
</CardGroup>