> ## 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. # Filtrage des comptes de tokens (ATA) > Capturez les transferts entrants de tokens SPL d'un portefeuille dans les flux gRPC de LaserStream avec l'expansion des comptes de tokens (ATA) — correspondance basée sur le propriétaire manqué par accountInclude. Le filtre `tokenAccounts` de LaserStream permet à un abonnement aux transactions gRPC de correspondre aux activités sur les **comptes de tokens associés (ATAs) qu'un portefeuille possède**, et pas seulement aux transactions où la clé publique du portefeuille apparaît directement. Le même filtre est disponible via WebSocket — voir [Filtrage des comptes de tokens (ATA) via WebSocket](/docs/fr/rpc/websocket/token-account-filtering). ## Le problème : les filtres de compte simples manquent les transferts de tokens entrants Quand vous surveillez un portefeuille avec `accountInclude: [wallet]`, vous ne faites correspondre que les transactions où la clé publique du portefeuille apparaît dans les clés de compte de la transaction. Un cas courant échappe à cette surveillance : lorsque quelqu'un envoie un token SPL au portefeuille (USDC, par exemple), le transfert touche le **compte de token associé (ATA)** du portefeuille — une adresse dérivée par programme distincte — pas la clé publique du portefeuille elle-même. Ainsi, un abonnement simple `accountInclude: [wallet]` ne voit jamais les transferts de tokens entrants. Vous devriez énumérer chaque ATA que le portefeuille possède à l'avance et ajouter chacun au filtre — mais les ATAs sont créés à la demande (un par frappe), vous ne pouvez donc pas connaître l'ensemble complet à l'avance. ## Comment fonctionne l'expansion `tokenAccounts` Définissez `tokenAccounts` sur un filtre de transaction pour élargir la correspondance afin qu'un portefeuille `accountInclude` **corresponde également** aux transactions qui touchent un compte de token qu'il possède. La correspondance est **basée sur le propriétaire** : LaserStream résout les comptes de tokens détenus par vos adresses `accountInclude` au moment de la correspondance, permettant de capturer tout compte de token que le portefeuille possède — y compris les non canoniques — pas seulement l'adresse ATA dérivée. Vous n'avez jamais à lister les ATAs vous-même. Les abonnements qui omettent `tokenAccounts` se comportent exactement comme avant, donc il est sûr de l'ajouter à un filtre existant. ## Modes d'expansion `tokenAccounts` prend l'une des trois valeurs de chaîne : | Valeur | Correspond à | Volume | Utilisation | | ------------------ | --------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------- | | `"balanceChanged"` | Transactions où un solde de token détenu a réellement changé (ou son compte de token a été fermé) | Inférieur — réglage par défaut recommandé | "Dites-moi quand l'argent a réellement bougé" — dépôts, retraits, échanges qui se règlent sur le portefeuille | | `"all"` | Toute transaction qui référence un compte de token que le portefeuille possède, même si le solde n'a pas changé | Supérieur | Visibilité complète sur tout ce qui touche de près ou de loin les comptes de tokens du portefeuille | | `"none"` | Aucune extension — identique à l'omission du champ | — | Le défaut | Commencez avec `"balanceChanged"`. Il capture les mouvements de fonds réels à une fraction du volume de `"all"`. ## Utilisation dans LaserStream gRPC Ajoutez `tokenAccounts` à un filtre de transaction dans votre `SubscribeRequest`. Le [SDK Helius LaserStream](/docs/fr/laserstream/clients) convertit la chaîne en enum de niveau filaire `TokenAccountExpansionControlFlag` pour vous (à partir de `yellowstone-grpc-proto` 12.5.0+). ```typescript theme={"system"} import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'; import bs58 from 'bs58'; const wallet = ''; const subscriptionRequest: SubscribeRequest = { transactions: { "wallet-activity": { accountInclude: [wallet], accountExclude: [], accountRequired: [], vote: false, failed: false, tokenAccounts: "balanceChanged" // also match the wallet's ATAs } }, 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) => { if (!data.transaction?.transaction) return; const tx = data.transaction.transaction; // Token balances this wallet owns that changed in the tx const owned = (tx.meta?.postTokenBalances || []).filter((b: any) => b.owner === wallet); console.log(bs58.encode(tx.signature), owned); }, async (error) => { console.error('Stream error:', error); }); ``` Voir le [guide de surveillance des transactions](/docs/fr/laserstream/guides/transaction-monitoring) pour un exemple plus complet qui compare les soldes avant et après, et la [référence de demande d'abonnement](/docs/fr/laserstream/grpc) pour chaque champ de filtre de transaction. ## Lecture de ce qui a été correspondant Une fois qu'une transaction correspond via l'expansion ATA, le mouvement de tokens du portefeuille se trouve dans `meta.postTokenBalances` et `meta.preTokenBalances` de la transaction. Filtrez ces entrées par `owner` pour isoler les soldes que votre portefeuille possède réellement, puis comparez `preTokenBalances` à `postTokenBalances` sur le même `accountIndex` pour voir combien chaque frappe a déplacé. L'exemple ci-dessus montre l'étape de filtrage ; le [guide de surveillance des transactions](/docs/fr/laserstream/guides/transaction-monitoring#exemple-4--surveiller-un-portefeuille-y-compris-les-transferts-de-tokens) montre la comparaison complète. ## Connexe Stratégies de filtrage complètes et exemple exécutable de surveillance de portefeuille via gRPC. Le même champ `tokenAccounts` sur la méthode WebSocket `transactionSubscribe`. Chaque champ de filtre de transaction, y compris `tokenAccounts`. Suivez des centaines de milliers de comptes dans un flux unique.