> ## 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. # Meilleures pratiques pour le SDK Rust > Recommandations de motifs Solana pour les agents IA utilisant le SDK Rust de Helius — historique des transactions, envoi, regroupement, webhooks, pagination, et gestion des erreurs. Meilleures pratiques et motifs recommandés pour les agents utilisant le [SDK Rust de Helius](https://github.com/helius-labs/helius-rust-sdk). Pour l'installation et le démarrage, voir l'[aperçu](/docs/fr/agents/rust-sdk). ## Recommandations pour les Agents ### Utilisez `get_transactions_for_address` au lieu de la recherche en deux étapes `get_transactions_for_address` combine la recherche de signature et la récupération de transaction en un seul appel avec filtrage côté serveur. ```rust theme={"system"} // GOOD: Single call, server-side filtering let txs = helius.rpc().get_transactions_for_address( "address".to_string(), GetTransactionsForAddressOptions { transaction_details: Some(TransactionDetails::Full), limit: Some(100), filters: Some(GetTransactionsFilters { token_accounts: Some(TokenAccountsFilter::BalanceChanged), ..Default::default() }), ..Default::default() }, ).await?; // BAD: Two calls, client-side filtering let sigs = helius.connection().get_signatures_for_address(&address)?; ``` ### Utilisez `send_smart_transaction` pour les envois standard Cela simule automatiquement, estime les unités de calcul, récupère les frais prioritaires et confirme. Ne construisez pas manuellement les instructions `ComputeBudget` — le SDK les ajoute automatiquement. ```rust theme={"system"} let sig = helius.send_smart_transaction(SmartTransactionConfig { create_config: CreateSmartTransactionConfig { instructions: vec![your_instruction], signers: vec![wallet_signer], priority_fee_cap: Some(100_000), cu_buffer_multiplier: Some(1.1), ..Default::default() }, ..Default::default() }).await?; ``` ### Utilisez Helius Sender pour une latence ultra-faible Pour les transactions sensibles au temps (arbitrage, sniping, liquidations), utilisez `send_smart_transaction_with_sender`. Il utilise l'infrastructure multi-régions de Helius et Jito. ```rust theme={"system"} let sig = helius.send_smart_transaction_with_sender( SmartTransactionConfig { create_config: CreateSmartTransactionConfig { instructions: vec![your_instruction], signers: vec![wallet_signer], ..Default::default() }, ..Default::default() }, SenderSendOptions { region: "US_EAST".to_string(), // Default, US_SLC, US_EAST, EU_WEST, EU_CENTRAL, EU_NORTH, AP_SINGAPORE, AP_TOKYO swqos_only: false, // true = SWQOS only (lower tip), false = Dual (SWQOS + Jito) poll_timeout_ms: 60_000, poll_interval_ms: 2_000, }, ).await?; ``` ### Utilisez `get_asset_batch` pour plusieurs actifs Lors de la récupération de plus d'un actif, regroupez-les. N'appelez pas `get_asset` dans une boucle. ```rust theme={"system"} // GOOD: Single request let assets = helius.rpc().get_asset_batch(GetAssetBatch { ids: vec!["mint1".to_string(), "mint2".to_string(), "mint3".to_string()], ..Default::default() }).await?; // BAD: N requests for id in mints { let asset = helius.rpc().get_asset(GetAsset { id, ..Default::default() }).await?; } ``` ### Utilisez les webhooks au lieu du polling Ne faites pas de polling de `get_transactions_for_address` dans une boucle. Utilisez les webhooks pour les notifications de serveur à serveur. ```rust theme={"system"} let webhook = helius.create_webhook(CreateWebhookRequest { webhook_url: "https://your-server.com/webhook".to_string(), webhook_type: WebhookType::Enhanced, transaction_types: vec![TransactionType::Transfer, TransactionType::NftSale, TransactionType::Swap], account_addresses: vec!["address_to_monitor".to_string()], auth_header: Some("Bearer your-secret".to_string()), ..Default::default() }).await?; ``` ## Pagination ### Basée sur un token/cursor (Méthodes RPC V2) ```rust theme={"system"} // get_transactions_for_address uses pagination_token let mut pagination_token: Option = None; let mut all_txs = Vec::new(); loop { let result = helius.rpc().get_transactions_for_address( "address".to_string(), GetTransactionsForAddressOptions { limit: Some(100), pagination_token: pagination_token.clone(), ..Default::default() }, ).await?; all_txs.extend(result.data); pagination_token = result.pagination_token; if pagination_token.is_none() { break; } } // Or use auto-paginating variants: let all_accounts = helius.rpc().get_all_program_accounts( program_id.to_string(), GetProgramAccountsV2Config::default(), ).await?; ``` ### Basée sur une page (API DAS) ```rust theme={"system"} let mut page = 1; let mut all_assets = Vec::new(); loop { let result = helius.rpc().get_assets_by_owner(GetAssetsByOwner { owner_address: "...".to_string(), page, limit: Some(1000), ..Default::default() }).await?; let count = result.items.len(); all_assets.extend(result.items); if count < 1000 { break; } page += 1; } ``` ## Filtre `token_accounts` Lors de la requête de `get_transactions_for_address`, le filtre `token_accounts` contrôle si l'activité du compte token est incluse : | Valeur | Comportement | Utiliser Quand | | ---------------- | -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- | | `None` | Seulement les transactions impliquant directement l'adresse | Vous vous souciez uniquement des transferts SOL et des appels de programmes | | `BalanceChanged` | Inclut également les transactions de tokens qui ont modifié un solde | **Recommandé pour la plupart des agents** — montre les envois/réceptions de tokens sans bruit | | `All` | Inclut toutes les transactions de compte token | Vous avez besoin de l'activité complète des tokens (peut retourner de nombreux résultats) | ## `changed_since_slot` — Récupération de Compte Incrémentielle `changed_since_slot` ne retourne que les comptes modifiés après un slot donné. Utile pour la synchronisation ou les workflows d'indexation. Supporté par `get_program_accounts_v2`, `get_token_accounts_by_owner_v2`, `get_account_info`, `get_multiple_accounts`, `get_program_accounts`, et `get_token_accounts_by_owner`. ```rust theme={"system"} // First fetch: get all accounts let baseline = helius.rpc().get_program_accounts_v2( program_id.to_string(), GetProgramAccountsV2Config { limit: Some(10_000), ..Default::default() }, ).await?; let last_slot = current_slot; // Later: only get accounts that changed since your last fetch let updates = helius.rpc().get_program_accounts_v2( program_id.to_string(), GetProgramAccountsV2Config { limit: Some(10_000), changed_since_slot: Some(last_slot), ..Default::default() }, ).await?; ``` ## Erreurs Courantes 1. **`transaction_details: Some(TransactionDetails::Full)` n'est pas le mode par défaut** — Par défaut, `get_transactions_for_address` retourne uniquement les signatures. Définissez `TransactionDetails::Full` pour obtenir les données complètes des transactions. 2. **N'ajoutez pas d'instructions ComputeBudget avec `send_smart_transaction`** — Le SDK les ajoute automatiquement. Ajouter les vôtres provoque une erreur `HeliusError::InvalidInput`. 3. **Les frais prioritaires sont en microlamports par unité de calcul** — Pas en lamports. Les valeurs de `get_priority_fee_estimate` sont déjà dans l'unité correcte. 4. **La pagination DAS commence à 1** — `page: 1` est la première page, pas `page: 0`. 5. **`async_connection()` nécessite `new_async` ou `HeliusBuilder`** — Appeler `helius.async_connection()` sur un client créé avec `Helius::new()` retourne `Err(HeliusError::ClientNotInitialized)`. 6. **`get_asset` retourne `Option`** — Une réponse réussie peut toujours être `None` si l'actif n'existe pas. Gérez explicitement `Option`. 7. **Les pourboires pour l'expéditeur sont obligatoires** — `send_smart_transaction_with_sender` détermine et ajoute automatiquement les pourboires. Minimum 0,0002 SOL (mode Dual) ou 0,000005 SOL (SWQOS uniquement). 8. **Indicateurs de fonctionnalité TLS** — La crate utilise par défaut `native-tls`. Utilisez `features = ["rustls"]` (et `default-features = false`) pour TLS en pur-Rust lorsque OpenSSL n'est pas disponible. 9. **Définissez la version maximale prise en charge des transactions à 1 lors de la récupération des transactions.** `get_transaction`, `get_block`, et `get_transactions_for_address` avec `TransactionDetails::Full` échouent avec l'erreur `-32015` sur la transaction v1 sinon. Sur les transactions v1, le frais prioritaire est le message de `transactionConfig.priorityFee`, un total en lamports ; il n'y a pas d'instructions ComputeBudget à analyser. Voir [Support de Transaction v1](/docs/fr/rpc/transaction-v1). ## Gestion des Erreurs et Nouveaux Essais Le SDK fournit des variantes d'erreurs typées via l'énumération `HeliusError`, vous pouvez donc les associer directement : ```rust theme={"system"} use helius::error::{HeliusError, Result}; match helius.rpc().get_asset(request).await { Ok(asset) => { /* success */ } Err(HeliusError::Unauthorized { .. }) => { /* 401: invalid or missing API key */ } Err(HeliusError::RateLimitExceeded { .. }) => { /* 429: too many requests or out of credits */ } Err(HeliusError::InternalError { .. }) => { /* 5xx: server error, retry with backoff */ } Err(HeliusError::NotFound { .. }) => { /* 404: resource not found */ } Err(HeliusError::BadRequest { .. }) => { /* 400: malformed request */ } Err(HeliusError::Timeout { .. }) => { /* transaction confirmation timed out */ } Err(e) => { /* other errors: Network, SerdeJson, etc. */ } } ``` ### Stratégie de nouveau essai Réessayez sur `RateLimitExceeded` et `InternalError` avec un backoff exponentiel : ```rust theme={"system"} async fn with_retry(f: F, max_retries: u32) -> Result where F: Fn() -> Fut, Fut: std::future::Future>, { for attempt in 0..=max_retries { match f().await { Ok(val) => return Ok(val), Err(HeliusError::RateLimitExceeded { .. }) | Err(HeliusError::InternalError { .. }) if attempt < max_retries => { tokio::time::sleep(std::time::Duration::from_millis(1000 * 2u64.pow(attempt))).await; } Err(e) => return Err(e), } } unreachable!() } ``` | Variante d'Erreur | Statut HTTP | Action | | ------------------- | ----------- | ----------------------------------------- | | `Unauthorized` | 401 | Vérifiez la clé API | | `RateLimitExceeded` | 429 | Délai d'attente et réessayez | | `InternalError` | 5xx | Réessayez avec un backoff exponentiel | | `BadRequest` | 400 | Corrigez les paramètres de la requête | | `NotFound` | 404 | Vérifiez si la ressource existe | | `Timeout` | — | Augmentez le délai d'attente ou réessayez |