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

# Token-Mint-Filterung

> Abonniere mit matchMints jede Transaktion in LaserStream gRPC, die einen Token-Mint berührt. So erfasst du SPL-Übertragungen, die accountInclude übersieht, weil der Mint nicht in den Account-Keys enthalten ist.

Mit dem Flag `matchMints` kann eine gRPC-Transaktions-Subscription von LaserStream zusätzlich zu den Account-Keys auch mit den **Token-Mints in den Token-Salden vor und nach einer Transaktion** abgeglichen werden.

Füge einen Mint zu `accountInclude` hinzu und aktiviere `matchMints: true`. Du empfängst dann jede Transaktion, die dieses Token berührt: Übertragungen, Swaps, Mint-to- und Burn-Vorgänge sowie Kontoschließungen.

<Note>
  `matchMints` ist nur für LaserStream gRPC verfügbar. Für LaserStream WebSocket ist es noch nicht verfügbar.
</Note>

## Das Problem: Einfache Kontofilter übersehen die meisten Token-Übertragungen

Wenn du ein Token mit `accountInclude: [mint]` überwachst, werden nur Transaktionen gefunden, bei denen der Mint-pubkey in den Account-Keys der Transaktion vorkommt.

Eine klassische SPL-Anweisung vom Typ `Transfer` verweist nie auf den Mint. Sie nennt nur das Quell-Token-Konto, das Ziel-Token-Konto und den Eigentümer. Deshalb übersieht ein einfacher Kontofilter den häufigsten Vorgang für jedes Token.

Nur Anweisungen, die den Mint direkt übergeben, werden gefunden. Dazu gehören `MintTo`, `Burn`, `TransferChecked` und Swaps, deren Programmkonten den Mint enthalten. Bisher bestand die einzige Alternative darin, alle Transaktionen zu streamen und die Token-Salden jeder Transaktion selbst zu prüfen.

## So funktioniert `matchMints`

Aktiviere `matchMints: true` für einen Transaktionsfilter. LaserStream erstellt dann aus `preTokenBalances` und `postTokenBalances` der Transaktion eine Menge von Mints.

Deine Listen `accountInclude`, `accountExclude` und `accountRequired` werden anschließend mit **sowohl** den Account-Keys als auch dieser Mint-Menge abgeglichen. Ein Mint erfüllt den Filter, wenn ein beliebiges zugehöriges Token-Konto in einer der beiden Saldenlisten erscheint. Dabei spielt es keine Rolle, ob sich der Saldo geändert hat.

Das Flag ist optional. Filter ohne dieses Flag verhalten sich exakt wie zuvor. Du kannst es daher zu einer bestehenden Subscription hinzufügen, ohne zu ändern, was diese bereits empfängt. SPL- und Token-2022-Mints funktionieren, weil beide Programme die Token-Salden vor und nach der Transaktion bereitstellen.

## Semantik

| Prädikat          | Ohne `matchMints`                                                                      | Mit `matchMints: true`                                                                                                                                |
| ----------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `accountInclude`  | Stimmt überein, wenn ein beliebiger aufgeführter Key in den Account-Keys enthalten ist | Stimmt überein, wenn ein beliebiger aufgeführter Key in den Account-Keys **oder** in der Mint-Menge enthalten ist                                     |
| `accountExclude`  | Lehnt ab, wenn ein beliebiger aufgeführter Key in den Account-Keys enthalten ist       | Lehnt ab, wenn ein beliebiger aufgeführter Key in den Account-Keys **oder** in der Mint-Menge enthalten ist                                           |
| `accountRequired` | Jeder aufgeführte Key muss in den Account-Keys enthalten sein                          | Jeder aufgeführte Key muss in den Account-Keys **oder** in der Mint-Menge enthalten sein. Jeder Key kann durch eine der beiden Mengen erfüllt werden. |

Die übrige Filterlogik bleibt unverändert:

* Prädikate innerhalb eines benannten Filters werden weiterhin mit AND verknüpft (`vote`, `failed`, `signature` und die Kontolisten).
* Mehrere benannte Filter werden weiterhin mit OR verknüpft.
* Werte innerhalb einer Liste werden mit OR verknüpft. Eine Ausnahme ist `accountRequired`, bei dem alle übereinstimmen müssen.
* Bei einer Transaktion ohne Token-Salden erfolgt der Abgleich nur anhand der Keys. `matchMints` fügt niemals Transaktionen ohne Token-Aktivität hinzu.
* `matchMints` allein schränkt den stream nicht ein. Damit der Filter akzeptiert wird, muss eine Kontoliste weiterhin mindestens einen Key oder Mint enthalten. Alternativ kannst du ein anderes einschränkendes Prädikat verwenden.

<Note>
  LaserStream gleicht Mints anhand des exakten pubkey ab. Anders als bei `tokenAccounts: "balanceChanged"` gibt es für Mints keinen Modus, der nur geänderte Salden berücksichtigt.
</Note>

## Verwendung in LaserStream gRPC

Füge `matchMints: true` zu einem Transaktionsfilter in deinem `SubscribeRequest` hinzu und trage den Mint in `accountInclude` ein. Dieses Beispiel streamt jede USDC-Transaktion im mainnet:

<Tabs>
  <Tab title="TypeScript">
    Erfordert `helius-laserstream` 0.8.5 oder höher. Das Feld wird auch als `match_mints` akzeptiert.

    ```typescript theme={"system"}
    import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream';
    import bs58 from 'bs58';

    const USDC = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';

    const subscriptionRequest: SubscribeRequest = {
      transactions: {
        'usdc-txs': {
          accountInclude: [USDC],
          accountExclude: [],
          accountRequired: [],
          vote: false,
          failed: false,
          matchMints: true, // match USDC via pre/post token-balance mints
        },
      },
      commitment: CommitmentLevel.CONFIRMED,
      accounts: {}, slots: {}, transactionsStatus: {},
      blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
    };

    const config: LaserstreamConfig = {
      apiKey: 'YOUR_API_KEY',
      endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com',
    };

    await subscribe(config, subscriptionRequest, async (data) => {
      const tx = data.transaction?.transaction;
      if (!tx) return;
      // USDC balances touched by this transaction
      const usdcBalances = (tx.meta?.postTokenBalances || []).filter((b: any) => b.mint === USDC);
      console.log(bs58.encode(tx.signature), usdcBalances);
    }, async (error) => {
      console.error('Stream error:', error);
    });
    ```
  </Tab>

  <Tab title="Rust">
    Erfordert `helius-laserstream` 0.6.4 oder höher. Dadurch wird `laserstream-core-proto` 11.3.0 eingebunden. Das Feld stammt direkt aus dem Proto-Crate.

    ```rust theme={"system"}
    use std::collections::HashMap;
    use helius_laserstream::grpc::{SubscribeRequest, SubscribeRequestFilterTransactions};

    let request = SubscribeRequest {
        transactions: HashMap::from([(
            "usdc-txs".to_string(),
            SubscribeRequestFilterTransactions {
                account_include: vec!["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v".to_string()],
                vote: Some(false),
                failed: Some(false),
                match_mints: true,
                ..Default::default()
            },
        )]),
        ..Default::default()
    };
    ```
  </Tab>

  <Tab title="Go">
    Erfordert das Go-Modul mit dem Tag `go/v0.3.0` oder höher.

    ```go theme={"system"}
    vote := false
    failed := false
    req := &laserstream.SubscribeRequest{
        Transactions: map[string]*laserstream.SubscribeRequestFilterTransactions{
            "usdc-txs": {
                AccountInclude: []string{"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"},
                Vote:           &vote,
                Failed:         &failed,
                MatchMints:     true,
            },
        },
        Commitment: &commitmentLevel,
    }
    ```
  </Tab>
</Tabs>

Wenn du statt des SDK einen direkten gRPC- oder Yellowstone-Client verwendest, generiere ihn erneut aus dem Helius-Proto. Verwende `laserstream-core-proto` 11.3.0 oder höher oder die im SDK-Repository enthaltene Datei `.proto`.

`match_mints` ist Feld 32 von `SubscribeRequestFilterTransactions`. Clients, die aus dem Upstream-Proto von Triton generiert wurden, verwerfen das unbekannte Feld ohne Meldung. Das Flag hat daher erst nach einer erneuten Generierung eine Wirkung.

Alle Felder des Transaktionsfilters findest du in der [Referenz zum Subscribe Request](/docs/de/laserstream/grpc#subscribe-request).

## Mit `tokenAccounts` kombinieren, um ein Token für eine Wallet zu überwachen

`matchMints` lässt sich mit der [Erweiterung `tokenAccounts`](/docs/de/laserstream/token-account-filtering) kombinieren. So kann ein einzelner Filter gleichzeitig Wallet-Eigentümer und Mints abgleichen.

Dieses Beispiel streamt jede Änderung am USDC-Saldo einer Wallet:

```typescript theme={"system"}
transactions: {
  'wallet-usdc': {
    accountInclude: [WALLET],
    accountRequired: [USDC],
    accountExclude: [],
    tokenAccounts: 'balanceChanged', // wallet matched via its token accounts
    matchMints: true,                // USDC matched via balance mints
    vote: false,
    failed: false,
  },
},
```

`accountInclude` zusammen mit `tokenAccounts` findet Transaktionen, bei denen sich die Token-Salden der Wallet geändert haben. `accountRequired` zusammen mit `matchMints` beschränkt diese auf Transaktionen mit USDC.

## Ermitteln, was übereingestimmt hat

Wenn eine Transaktion aufgrund eines Mint übereinstimmt, suche den Mint in `meta.preTokenBalances[].mint` und `meta.postTokenBalances[].mint`. Bei einfachen Übertragungen fehlt der Mint normalerweise in den Account-Keys. Suche dort also nicht danach.

Vergleiche `preTokenBalances` und `postTokenBalances` für denselben `accountIndex`. So erkennst du, wie viele Token zwischen welchen Eigentümern übertragen wurden.

Der [Leitfaden zur Transaktionsüberwachung](/docs/de/laserstream/guides/transaction-monitoring#datenstruktur-der-transaktion) beschreibt die Transaktionsstruktur ausführlich.

## Limits und Hinweise

* Mints werden in dieselben Listen `accountInclude`, `accountExclude` und `accountRequired` wie Account-Keys eingetragen. Daher gelten für sie dieselben listenbezogenen Limits des Tarifs. Es gibt kein separates Mint-Limit.
* Der Aufwand für den Abgleich wächst nicht mit der Anzahl der aufgeführten Mints. 100 Mints und 100.000 Mints bieten dieselbe Leistung. Für Abonnenten, die das Flag nicht aktivieren, entsteht kein zusätzlicher Aufwand.
* Die [historische Wiedergabe](/docs/de/laserstream/historical-replay) berücksichtigt `matchMints`. Eine Wiedergabe-Subscription gibt daher dieselben Transaktionen zurück wie der Live-stream.
* Wenn du einer Transaktions-Subscription einen [komprimierten Cuckoo-Filter](/docs/de/laserstream/cuckoo-filters) hinzufügst, prüft `matchMints` neben den Account-Keys auch die Mint-Menge dagegen.
* `matchMints` ist in allen LaserStream gRPC-Regionen sowie im mainnet und devnet aktiv. Für LaserStream WebSocket ist es derzeit nicht verfügbar.
* SDK-Mindestversionen: JavaScript/TypeScript `helius-laserstream` 0.8.5, Rust `helius-laserstream` 0.6.4, Go `go/v0.3.0`.

## Verwandte Themen

<CardGroup cols={2}>
  <Card title="Token Account (ATA) Filtering" icon="coins" href="/docs/de/laserstream/token-account-filtering">
    Finde Transaktionen, die Token-Konten einer Wallet berühren
  </Card>

  <Card title="Transaction Monitoring" icon="receipt" href="/docs/de/laserstream/guides/transaction-monitoring">
    Vollständige Filterstrategien und ausführbare Beispiele für gRPC
  </Card>

  <Card title="Subscribe Request Reference" icon="filter" href="/docs/de/laserstream/grpc">
    Alle Felder des Transaktionsfilters einschließlich `matchMints`
  </Card>

  <Card title="Historical Replay" icon="clock-rotate-left" href="/docs/de/laserstream/historical-replay">
    Führe mit demselben Filter ein backfill für bis zu 24 Stunden Token-Aktivität aus
  </Card>
</CardGroup>