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

# Pump.fun Token-Mints mit geparsten Events abrufen

> Durchsuchen Sie die Historie einer Solana-Adresse mit Helius Parsed Events und extrahieren Sie Pump.fun-Erstellungsanweisungen — Token-Mint, Ersteller, Name, Symbol und URI.

Dieser Leitfaden ruft **jeden Token ab, den eine Wallet auf Pump.fun eingesetzt hat**. Er durchläuft die geparste Historie der Wallet und wählt die beiden Anweisungen aus, die Pump.fun zum Starten eines Tokens verwendet, bis die Historie erschöpft ist.

Es ist das historische Gegenstück zum Parsed Streams-Leitfaden [Pump.fun Mints verfolgen](/docs/de/parsed-streams/guides/track-pumpfun-mints): das gleiche Programm, die gleichen Anweisungsnamen und die gleichen dekodierten Felder — auf Abruf abgerufen, statt in Echtzeit gepusht.

<Steps>
  <Step title="Programm nachschlagen">
    Pump.fun startet Tokens durch zwei Anweisungen, abhängig von der Version: `create` und `create_v2`. Parsed Events dekodiert Anweisungen über den gleichen IDL-Katalog, den Parsed Streams verwendet. Bestätigen Sie die genauen dekodierten Namen und Konto-Rollen mit seiner [`describeProgram`](/docs/de/parsed-streams/quickstart#entdeckung) Methode, bevor Sie diese abgleichen:

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

    Überprüfen Sie die `instructions`-Liste der Antwort auf `create` und `create_v2`, und deren `roles`-Liste für das gewünschte Konto — typischerweise die neue **Mint**-Adresse, und entweder eine `creator`-Konto-Rolle oder ein `creator`-Feld in `args`. Die beiden Anweisungsversionen haben nicht unbedingt die gleiche Struktur, weshalb der Code unten sowohl ein Argument als auch ein paar Rollennamen überprüft, anstatt eine anzunehmen.
  </Step>

  <Step title="Anfrage erstellen">
    Holen Sie die Historie der Ersteller-Wallet seitenweise ab:

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

    Drei Unterschiede zum Streaming-Filter, die man von Anfang an wissen sollte:

    * `address` ist immer erforderlich — programmweite Scans werden nicht unterstützt, daher holen Sie die Deploys einer Wallet und nicht alle Deploys auf Pump.fun ab. Für den Firehose verwenden Sie [Parsed Streams](/docs/de/parsed-streams/guides/track-pumpfun-mints).
    * Die Anfrage hat keinen serverseitigen Anweisungsfilter. Die Historie gibt alles zurück, was die Adresse berührt hat, und Sie wählen die Pump.fun-Anweisungen clientseitig im nächsten Schritt aus.
    * Es gibt keinen `includeFailed`-Schalter. Die Historie gibt erfolgreiche und fehlgeschlagene Transaktionen gleichermaßen zurück, also überprüfen Sie `parsed.transactionStatus` clientseitig — ein fehlgeschlagener Deploy erzeugt niemals ein aktives Mint.
  </Step>

  <Step title="Historie durchblättern">
    Jedes Ergebnis enthält **jede** Anweisung der Transaktion. Scannen Sie `parsed.instructions` nach den `create`/`create_v2`-Treffern und geben Sie `paginationToken` zurück, bis es verschwindet:

    ```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="Jede Bereitstellung extrahieren">
    Ziehen Sie das Mint, den Ersteller und die Metadaten aus der dekodierten Anweisung, genau wie es der Streaming-Listener tut:

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

    Überprüfen Sie, ob `ix.decoded` vorhanden ist, bevor Sie `args` und `accounts` vertrauen — ein nicht erkannter Build des Pump.fun-Programms würde sonst als `mint: null` erscheinen, wobei nur `rawData` und `rawAccounts` zur Verfügung stehen.
  </Step>
</Steps>

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Pump.fun Mints verfolgen" icon="rocket" href="/docs/de/parsed-streams/guides/track-pumpfun-mints">
    Die Echtzeitversion: ein reconnect-sicherer Listener, der jeden neuen Deploy beim Eintreffen protokolliert.
  </Card>
</CardGroup>