> ## 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. # LaserStream gRPC Démarrage rapide > Installez le SDK, choisissez un endpoint, et diffusez vos premières transactions Solana via LaserStream gRPC — endpoints, référence de demande de souscription, et exemples. ## Vue d'ensemble LaserStream est un service de streaming gRPC Solana géré. Il est compatible avec le protocole ouvert Yellowstone gRPC — donc tout client Yellowstone fonctionne immédiatement — et ajoute des fonctionnalités de production comme la relecture historique, le basculement multi-nœuds, et un environnement entièrement géré. LaserStream utilise le protocole open source gRPC, garantissant aucune dépendance vis-à-vis d'un fournisseur et une compatibilité maximale avec les implémentations gRPC existantes. Vous pouvez vous connecter soit avec le client standard `@triton-one/yellowstone-grpc` soit utiliser le **[Helius LaserStream SDK](/docs/fr/laserstream/clients)** optimisé pour des performances accrues, y compris un débit plus élevé, des reconnexions automatiques, une gestion des abonnements, la gestion des erreurs, et plus encore. Découvrez comment nous avons utilisé Rust Core avec des liaisons NAPI sans copie pour optimiser les performances du SDK JavaScript **Avis de performance**: Si vous rencontrez un décalage ou des problèmes de performance avec votre connexion LaserStream, veuillez consulter la [section Dépannage](#dépannage--faq) pour les causes courantes et les solutions. ## Endpoints et Régions LaserStream est disponible dans plusieurs régions dans le monde. Choisissez le endpoint le plus proche de votre application pour des performances optimales : ### Endpoints Mainnet | Région | Emplacement | Endpoint | | -------- | ------------------------------- | ------------------------------------------------- | | **ewr** | Newark, NJ (près de New York) | `https://laserstream-mainnet-ewr.helius-rpc.com` | | **pitt** | Pittsburgh, US (Centre) | `https://laserstream-mainnet-pitt.helius-rpc.com` | | **slc** | Salt Lake City, US (Côte Ouest) | `https://laserstream-mainnet-slc.helius-rpc.com` | | **lax** | Los Angeles, US (Côte Ouest) | `https://laserstream-mainnet-lax.helius-rpc.com` | | **lon** | Londres, Europe | `https://laserstream-mainnet-lon.helius-rpc.com` | | **ams** | Amsterdam, Europe | `https://laserstream-mainnet-ams.helius-rpc.com` | | **fra** | Francfort, Europe | `https://laserstream-mainnet-fra.helius-rpc.com` | | **tyo** | Tokyo, Asie | `https://laserstream-mainnet-tyo.helius-rpc.com` | | **sgp** | Singapour, Asie | `https://laserstream-mainnet-sgp.helius-rpc.com` | ### Endpoint Devnet | Réseau | Emplacement | Endpoint | | ---------- | ----------------------------- | ----------------------------------------------- | | **Devnet** | Newark, NJ (près de New York) | `https://laserstream-devnet-ewr.helius-rpc.com` | **Sélection du réseau et de la région** : * Pour les **applications de production**, choisissez le endpoint mainnet le plus proche de votre serveur pour de meilleures performances (par exemple, si déployé en Europe, utilisez Amsterdam (`ams`) ou Francfort (`fra`)) * Pour **tester**, utilisez : `https://laserstream-devnet-ewr.helius-rpc.com`. ### `zstd` Compression Tous les endpoints gRPC LaserStream prennent en charge la compression `zstd`. La compression est facultative : les réponses restent non compressées à moins que votre client ne prenne en charge `zstd`. Activez `zstd` dans le Helius LaserStream TypeScript SDK : ```typescript theme={"system"} import { CompressionAlgorithms } from 'helius-laserstream' import type { LaserstreamConfig } from 'helius-laserstream' const config: LaserstreamConfig = { apiKey: 'YOUR_API_KEY', endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', channelOptions: { 'grpc.default_compression_algorithm': CompressionAlgorithms.zstd, }, } ``` `zstd` réduit la bande passante réseau, mais ajoute du travail de compression. Évaluez cela avec votre charge de souscription avant de l'activer pour les flux sensibles à la latence. ### Troncature des journaux Par défaut, LaserStream tronque les messages des journaux de transactions à **10 KB** pour améliorer la vitesse et la performance. Si vous avez besoin de journaux complets, des endpoints dédiés sans troncature sont disponibles — voir [Troncature des journaux](/docs/fr/laserstream/log-truncation). ## Démarrage rapide Commencez avec LaserStream depuis votre [Tableau de bord Helius](https://dashboard.helius.dev/laserstream). Mainnet nécessite un plan Business ou Professional ; Devnet est disponible sur Developer et au-delà. Voir [Plans & Tarification](/docs/fr/billing/plans) pour plus de détails. ```bash theme={"system"} mkdir laserstream-grpc-demo cd laserstream-grpc-demo npm init -y ``` ```bash theme={"system"} npm install helius-laserstream npm install --save-dev typescript tsx @types/node ``` Nous utilisons `tsx` car le défaut `npx tsc --init` sur TypeScript 5.x définit `verbatimModuleSyntax`, `module: "nodenext"`, et `types: []`, ce qui casse un rapide `ts-node index.ts` run. `tsx` exécute les fichiers `.ts` sans tsconfig. Générez une clé depuis le [Tableau de bord Helius](https://dashboard.helius.dev/). Cette clé servira de jeton d'authentification pour LaserStream. **Exigences du plan**: LaserStream devnet est disponible sur tous les [plans](/docs/fr/billing/plans). LaserStream mainnet nécessite un plan Business ou Professional. Créez **`index.ts`** avec ce qui suit : ```typescript theme={"system"} import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream' async function main() { const subscriptionRequest: SubscribeRequest = { transactions: { "token-filter": { // user-defined label for this filter accountInclude: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'], accountExclude: [], accountRequired: [], vote: false, failed: false } }, commitment: CommitmentLevel.CONFIRMED, accounts: {}, slots: {}, transactionsStatus: {}, blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [], // Optionally, you can replay missed data by specifying a `fromSlot` (u64 number): // fromSlot: currentSlot - 1000, // Note: replay is currently limited to the last ~216,000 slots (≈24 hours). }; // Replace the values below with your actual LaserStream API key and endpoint const config: LaserstreamConfig = { apiKey: 'YOUR_API_KEY', // Replace with your key from https://dashboard.helius.dev/ endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region } await subscribe(config, subscriptionRequest, async (data) => { console.log(data); }, async (error) => { console.error(error); }); } main().catch(console.error); ``` Dans `index.ts`, mettez à jour l'objet `config` avec : 1. Votre clé API réelle du [Tableau de bord Helius](https://dashboard.helius.dev/) 2. Le endpoint LaserStream le plus proche de l'emplacement de votre serveur ```typescript theme={"system"} const config: LaserstreamConfig = { apiKey: 'YOUR_ACTUAL_API_KEY', // Replace with your key from Helius Dashboard endpoint: 'https://laserstream-mainnet-fra.helius-rpc.com', // Example: Frankfurt mainnet // For devnet: endpoint: 'https://laserstream-devnet-ewr.helius-rpc.com' } ``` **Exemples de sélection de réseau et de région :** * **Pour la production (Mainnet)** : * Europe : Utilisez `fra` (Francfort), `ams` (Amsterdam), ou `lon` (Londres) * US Est : Utilisez `ewr` (New York) * US Ouest : Utilisez `slc` (Salt Lake City) ou `lax` (Los Angeles) * Asie : Utilisez `tyo` (Tokyo) ou `sgp` (Singapour) * **Pour le développement (Devnet)** : * Utilisez `https://laserstream-devnet-ewr.helius-rpc.com` ```bash theme={"system"} npx tsx index.ts ``` Chaque fois qu'une transaction sur le token `confirmed` implique `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`, vous verrez les données dans votre console. ## Flux de travail courants Guides étape par étape pour les flux de travail que nous voyons le plus souvent. Chaque guide utilise le SDK [`helius-laserstream`](/docs/fr/laserstream/clients) avec reconnexion automatique et relecture historique intégrées. Surveillez les changements de solde, de données et de propriété sur des comptes spécifiques avec des filtres. Diffusez des transactions impliquant des comptes cibles, filtrer par programme, vote ou statut d'échec. Suivez le consensus du réseau, la production de blocs et les transitions de niveau d'engagement. Analysez les charges utiles binaires `transactionUpdate` en transactions Solana lisibles. Exemple réel : surveillez les échanges AMM Pump avec des filtres sûrs pour la reconnexion. Le client `@triton-one/yellowstone-grpc` fonctionne avec les mêmes endpoints si vous préférez le protocole Yellowstone brut. Consultez la [référence gRPC Yellowstone](/docs/fr/grpc) pour les détails au niveau du protocole. ## Demande de souscription Dans la demande de souscription, vous devez inclure les paramètres généraux suivants : **Relecture historique :** Vous pouvez inclure facultativement un champ `fromSlot` (un nombre `u64`) dans l'objet principal `SubscribeRequest` pour relire les données à partir d'un slot spécifique. La relecture est actuellement limitée aux 216,000 derniers slots (≈24 heures) ; notez que [les relectures plus anciennes que \~20 minutes retournent uniquement des données finalisées](/docs/fr/laserstream/historical-replay#jusquoù-pouvez-vous-rejouer-). Spécifie le niveau d'engagement, qui peut être **traité**, **confirmé**, ou **finalisé**. Un tableau d'objets `{ offset: uint64, length: uint64 }` qui vous permet de recevoir uniquement les tranches de données requises des comptes. Certains fournisseurs de cloud (comme Cloudflare) peuvent fermer les flux inactifs après une période d'inactivité. Pour éviter cela et garder la connexion active sans avoir besoin de renvoyer des filtres, réglez ceci sur **true**. Le serveur répondra avec un message Pong toutes les 15 secondes. ```typescript theme={"system"} const subscriptionRequest: SubscribeRequest = { commitment: CommitmentLevel.CONFIRMED, accountsDataSlice: [], transactions: {}, accounts: {}, slots: {}, blocks: {}, blocksMeta: {}, entry: {}, } ``` Ensuite, vous devrez spécifier les filtres pour les données auxquelles vous souhaitez vous abonner, telles que les comptes, blocs, slots, ou transactions. Définissez des filtres pour les mises à jour de slot. La clé que vous utilisez (par exemple, `mySlotLabel`) est un **label défini par l'utilisateur** pour cette configuration de filtre spécifique, vous permettant de définir potentiellement plusieurs configurations nommées si nécessaire (bien que généralement une seule soit suffisante). Par défaut, les slots sont envoyés pour tous les niveaux d'engagement. Avec ce filtre, vous pouvez choisir de recevoir uniquement le niveau d'engagement sélectionné. Active l'abonnement pour recevoir des mises à jour pour les changements à l'intérieur d'un slot, non pas seulement au début de nouveaux slots. Cela est utile pour des données de slot plus granulaires et à faible latence. ```typescript theme={"system"} slots: { // mySlotLabel is a user-defined name for this slot update filter configuration mySlotLabel: { // filterByCommitment: true => Only broadcast slot updates at the specified subscribeRequest commitment filterByCommitment: true // interslotUpdates: true allows receiving updates for changes occurring within a slot, not just new slots. interslotUpdates: true } }, ``` Définissez des filtres pour les mises à jour de données de compte. La clé que vous utilisez (par exemple, `tokenAccounts`) est un **label défini par l'utilisateur** pour cette configuration de filtre spécifique. Correspond à toute clé publique de la liste fournie. La clé publique du propriétaire du compte. Correspond à toute clé publique de la liste fournie. Similaire aux filtres dans [getProgramAccounts](https://solana.com/docs/rpc/http/getprogramaccounts). C'est un tableau de filtres `datasize` et/ou `memcmp`. Pour `memcmp`, le comparant se trouve sur l'un de `bytes`, `base58`, ou `base64` directement sur l'objet `memcmp`. **Obsolète — sans effet à partir de Agave 4.2.** Définir `notifyOn` n'a aucun effet. Le champ sera supprimé à une date ultérieure. Si tous les champs sont vides, tous les comptes sont diffusés. Sinon : * Les champs fonctionnent comme un **ET** logique. * Les valeurs dans les tableaux agissent comme un **OU** logique (sauf dans `filters`, qui fonctionnent comme un **ET** logique). ```typescript theme={"system"} accounts: { // tokenAccounts is a user-defined label for this account filter configuration tokenAccounts: { // Matches any of these public keys (logical OR) account: ["9SHQTA66Ekh7ZgMnKWsjxXk6DwXku8przs45E8bcEe38"], // Matches owners that are any of these public keys owner: ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"], // Filters - all must match (AND logic) filters: [ { datasize: 165 }, { memcmp: { offset: 0, base58: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" } } ] } }, ``` Suivez plus de \~10,000 comptes ? Au lieu d'une liste de clés publiques explicite (32 octets par compte), utilisez un [filtre de cuckoo](/docs/fr/laserstream/cuckoo-filters) (\~3–4 octets par compte) pour vous abonner à des centaines de milliers de comptes en un seul flux. Disponible dans les SDK Rust et JavaScript. Définissez des filtres pour les mises à jour de transactions. La clé que vous utilisez (par exemple, `myTxSubscription`) est un **label défini par l'utilisateur** pour cette configuration de filtre spécifique. Activez ou désactivez la diffusion des transactions de vote. Activez ou désactivez la diffusion des transactions échouées. Diffusez uniquement les transactions correspondant à la signature spécifiée. Filtrez les transactions impliquant tout compte de la liste fournie. Excluez les transactions impliquant tout compte de la liste fournie (opposé de `accountInclude`). Filtrez les transactions impliquant tous les comptes de la liste fournie (tous les comptes doivent être utilisés). Extension facultative `tokenAccounts` (compte token associé). Lorsqu'il est défini, un portefeuille `accountInclude` correspond également aux transactions où il **possède** un solde token SPL — par exemple, les transferts de tokens entrants qui touchent le compte token du portefeuille plutôt que sa clé publique. Accepte `"balanceChanged"` (correspondances de delta de solde), `"all"` (toute référence, volume plus élevé), ou `"none"` (aucune expansion, le défaut). Le SDK convertit la chaîne en l'enum du niveau filaire `TokenAccountExpansionControlFlag` (partie de `yellowstone-grpc-proto` 12.5.0+). Voir [Filtrage de compte token (ATA)](/docs/fr/laserstream/token-account-filtering) pour ce qu'il fait et comment cela fonctionne. Si tous les champs sont laissés vides, toutes les transactions sont diffusées. Sinon : * Les champs fonctionnent comme un **ET** logique. * Les valeurs dans les tableaux sont traitées comme un **OU** logique (sauf pour `accountRequired`, où tous doivent correspondre). ```typescript theme={"system"} transactions: { // myTxSubscription is a user-defined label for this transaction filter configuration myTxSubscription: { vote: false, failed: false, signature: "", // Transaction must include at least one of these public keys (OR) accountInclude: ["86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"], // Exclude if it matches any of these accountExclude: [], // Require all accounts in this array (AND) accountRequired: [] } }, ``` Définissez des filtres pour les mises à jour de bloc. La clé que vous utilisez (par exemple, `myBlockLabel`) est un **label défini par l'utilisateur** pour cette configuration de filtre spécifique. Filtre les transactions et comptes impliquant tout compte de la liste fournie. Inclut toutes les transactions dans la diffusion. Inclut toutes les mises à jour de compte dans la diffusion. Inclut toutes les entrées dans la diffusion. ```typescript theme={"system"} blocks: { // myBlockLabel is a user-defined label for this block filter configuration myBlockLabel: { // Only broadcast blocks referencing these accounts accountInclude: ["86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"], includeTransactions: true, includeAccounts: false, includeEntries: false } }, ``` Cela fonctionne de manière similaire aux Blocs mais exclut les transactions, les comptes et les entrées. La clé que vous utilisez (par exemple, `blockmetadata`) est un **label défini par l'utilisateur** pour cette souscription. Actuellement, aucun filtre n'est disponible pour les métadonnées de bloc — tous les messages sont diffusés par défaut. ```typescript theme={"system"} blocksMeta: { blockmetadata: {} }, ``` Abonnez-vous aux entrées du registre. La clé que vous utilisez (par exemple, `entrySubscribe`) est un **label défini par l'utilisateur** pour cette souscription. Actuellement, il n'existe pas de filtres disponibles pour les entrées ; toutes les entrées sont diffusées. ```typescript theme={"system"} entry: { entrySubscribe: {} }, ``` ## Exemples de code (SDK LaserStream) ```typescript theme={"system"} import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream' async function main() { const subscriptionRequest: SubscribeRequest = { transactions: {}, commitment: CommitmentLevel.CONFIRMED, accounts: {}, slots: { slot: { filterByCommitment: true }, }, transactionsStatus: {}, blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [], }; const config: LaserstreamConfig = { apiKey: 'YOUR_API_KEY', // Replace with your key endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region } await subscribe(config, subscriptionRequest, async (data) => { console.log(data); }, async (error) => { console.error(error); }); } main().catch(console.error); ``` ```typescript theme={"system"} import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream' async function main() { const subscriptionRequest: SubscribeRequest = { accounts: { "usdc-account": { // user-defined label for this filter account: ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"], // USDC mint account owner: [], filters: [] } }, accountsDataSlice: [], commitment: CommitmentLevel.CONFIRMED, slots: {}, transactions: {}, transactionsStatus: {}, blocks: {}, blocksMeta: {}, entry: {} }; const config: LaserstreamConfig = { apiKey: 'YOUR_API_KEY', // Replace with your key endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region } await subscribe(config, subscriptionRequest, async (data) => { console.log(data); }, async (error) => { console.error(error); }); } main().catch(console.error); ``` ```typescript theme={"system"} import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream' async function main() { const subscriptionRequest: SubscribeRequest = { transactions: { "token-filter": { // user-defined label for this filter accountInclude: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'], accountExclude: [], accountRequired: [], vote: false, failed: false } }, commitment: CommitmentLevel.CONFIRMED, accounts: {}, slots: {}, transactionsStatus: {}, blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [], }; const config: LaserstreamConfig = { apiKey: 'YOUR_API_KEY', // Replace with your key endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region } await subscribe(config, subscriptionRequest, async (data) => { console.log(data); }, async (error) => { console.error(error); }); } main().catch(console.error); ``` ```typescript theme={"system"} import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream' async function main() { const subscriptionRequest: SubscribeRequest = { entry: {}, accounts: {}, accountsDataSlice: [], slots: {}, blocks: { blocks: { accountInclude: [] } }, blocksMeta: {}, transactions: {}, transactionsStatus: {}, commitment: CommitmentLevel.CONFIRMED, }; const config: LaserstreamConfig = { apiKey: 'YOUR_API_KEY', // Replace with your key endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region } await subscribe(config, subscriptionRequest, async (data) => { console.log(data); }, async (error) => { console.error(error); }); } main().catch(console.error); ``` ```typescript theme={"system"} import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream' async function main() { const subscriptionRequest: SubscribeRequest = { entry: {}, accounts: {}, accountsDataSlice: [], slots: {}, blocks: {}, blocksMeta: { blockmetadata: {} }, transactions: {}, transactionsStatus: {}, commitment: CommitmentLevel.CONFIRMED, }; const config: LaserstreamConfig = { apiKey: 'YOUR_API_KEY', // Replace with your key endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region } await subscribe(config, subscriptionRequest, async (data) => { console.log(data); }, async (error) => { console.error(error); }); } main().catch(console.error); ``` ```typescript theme={"system"} import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream' async function main() { const subscriptionRequest: SubscribeRequest = { entry: { entrySubscribe: {} // Subscribe to all entries }, accounts: {}, accountsDataSlice: [], slots: {}, blocks: {}, blocksMeta: {}, transactions: {}, transactionsStatus: {}, commitment: CommitmentLevel.CONFIRMED, }; const config: LaserstreamConfig = { apiKey: 'YOUR_API_KEY', // Replace with your key endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region } await subscribe(config, subscriptionRequest, async (data) => { console.log(data); }, async (error) => { console.error(error); }); } main().catch(console.error); ``` ## Options de SDK Nous fournissons des SDK officiels pour plusieurs langages de programmation : * **TypeScript**: [LaserStream TypeScript SDK](https://github.com/helius-labs/laserstream-sdk) * **Rust**: [LaserStream Rust SDK](https://github.com/helius-labs/laserstream-sdk/tree/main/rust) * **Go**: [LaserStream Go SDK](https://github.com/helius-labs/laserstream-sdk/tree/main/go) Pour d'autres langages ou implémentations personnalisées, vous pouvez utiliser directement les [fichiers proto gRPC Yellowstone](https://github.com/rpcpool/yellowstone-grpc/tree/v6.0.0%2Bsolana.2.2.12/yellowstone-grpc-proto/proto) pour générer des clients gRPC pour votre langage préféré. ## Dépannage / FAQ **A:** Les problèmes de performance avec les connexions LaserStream sont généralement causés par : * **Lenteur du client JavaScript**: Le client JavaScript peut prendre du retard lors du traitement de trop nombreux messages ou de la consommation d'une bande passante excessive. Envisagez de filtrer vos souscriptions plus étroitement pour réduire le volume de messages, passez au [SDK JavaScript LaserStream](/docs/fr/laserstream/clients), ou essayez d'utiliser un autre langage. * **Bande passante locale limitée**: Les souscriptions lourdes peuvent submerger les clients avec une bande passante réseau limitée. Surveillez votre utilisation du réseau et envisagez de mettre à niveau votre connexion ou de réduire la portée de la souscription. * **Distance géographique**: Les longs trajets réseau augmentent la latence et la perte de paquets. Utilisez le [endpoint le plus proche de votre serveur](#endpoints-mainnet). Pour les connexions à haute latence, augmentez vos tailles de tampon de lecture réseau (peut améliorer la bande passante de 5x+) : ```bash theme={"system"} sudo sysctl -w net.core.rmem_max=67108864 net.ipv4.tcp_rmem="4096 87380 67108864" ``` Pour persister après les redémarrages, ajoutez à `/etc/sysctl.conf` : ```bash theme={"system"} net.core.rmem_max=67108864 net.ipv4.tcp_rmem=4096 87380 67108864 ``` Augmentez les tailles de fenêtre de flux **et de connexion** HTTP/2 à 64 Mo pour éviter les goulots d'étranglement du contrôle de flux. Les deux sont nécessaires — élever seulement la fenêtre de flux laisse la fenêtre de niveau de connexion comme contrainte de liaison : ```rust theme={"system"} // Rust (tonic) Channel::from_static("https://laserstream-mainnet-ewr.helius-rpc.com") .initial_stream_window_size(1024 * 1024 * 64) // 64MB stream window .initial_connection_window_size(1024 * 1024 * 64) // 64MB connection window .connect() .await?; ``` * **Goulots d'étranglement côté client**: Assurez-vous que votre logique de traitement des messages est optimisée et ne bloque pas le thread principal pendant de longues périodes. **Débogage du décalage client**: Pour vous aider à déboguer le client, nous avons construit un outil pour tester la bande passante maximale de votre nœud à un serveur gRPC Laserstream. Pour l'utiliser, exécutez : ``` cargo install helius-laserstream-bandwidth helius-laserstream-bandwidth --laserstream-url $LASERSTREAM_URL --api-key $API_KEY ``` La sortie retourne la capacité réseau maximale entre votre serveur et le serveur Laserstream. Au minimum, vous avez besoin de 10 Mo/s pour vous abonner à toutes les données de transaction et de 80 Mo/s pour vous abonner à toutes les données de compte. Nous recommandons d'avoir au moins 2x la capacité requise pour des performances optimales. **A:** Vérifiez que votre clé API et votre endpoint sont corrects et que votre réseau permet les connexions gRPC sortantes vers le endpoint spécifié. Vérifiez la [page de statut Helius](https://helius.statuspage.io/) pour tout incident en cours. **A:** Revérifiez les opérateurs logiques (ET/OU) décrits dans les sections de filtres. Assurez-vous que les clés publiques sont correctes. Vérifiez le niveau d'engagement spécifié dans votre demande. **A:** Oui, vous pouvez définir des configurations de filtre sous plusieurs clés (par exemple, `accounts`, `transactions`) dans le même objet `SubscribeRequest`. **A:** Nous n'implémentons pas de groupes de consommateurs. Au lieu de cela, LaserStream offre les résultats mêmes que souhaitent les équipes : reprise, relecture, et fiabilité multi-nœuds sans couche de coordination (et la latence/surcharge qui l'accompagnent). Nous croyons que les groupes de consommateurs ne sont pas nécessaires pour la plupart des charges de travail et qu'ils ajoutent de la latence et une surcharge opérationnelle. Par exemple, une seule connexion gRPC LaserStream peut émettre jusqu'à 10× les données de transaction + compte de Solana, et la plupart des clients s'abonnent à une petite tranche filtrée. Utiliser des groupes de consommateurs dans ce cas consomme des ressources de performance et introduit un autre point de défaillance. **A:** LaserStream tronque les messages de journal de transaction à 10 KB par défaut pour une meilleure vitesse et performance. Si vous avez besoin de journaux complets, connectez-vous à un endpoint dédié sans troncature — voir [Troncature des journaux](/docs/fr/laserstream/log-truncation) pour la liste. **A:** Inclure un champ `ping` dans votre initiale `SubscribeRequest` amène LaserStream à ignorer silencieusement tous les filtres d'abonnement — seul un Pong est retourné sans données de compte, de transaction, ou de slot. Pour corriger cela, retirez `ping` de la demande de souscription initiale et envoyez plutôt des pings séparément via le récepteur du flux après l'établissement de la souscription. Cela maintient la connexion active sans interférer avec vos filtres.