> ## 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. # Rust SDK Best Practices > Empfohlene Solana-Muster für KI-Agenten mit dem Helius Rust SDK — Transaktionshistorie, Senden, Batch-Verarbeitung, Webhooks, Paginierung und Fehlerbehandlung. Beste Praktiken und empfohlene Muster für Agenten, die das [Helius Rust SDK](https://github.com/helius-labs/helius-rust-sdk) verwenden. Für Installation und Einstieg siehe die [Übersicht](/docs/de/agents/rust-sdk). ## Empfehlungen für Agenten ### Verwenden Sie `get_transactions_for_address` anstelle des Zweistufen-Lookups `get_transactions_for_address` kombiniert Signatur-Lookup und Transaktionsabruf in einem einzigen Aufruf mit serverseitiger Filterung. ```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)?; ``` ### Verwenden Sie `send_smart_transaction` für Standardübertragungen Es simuliert automatisch, schätzt Berechnungseinheiten, ruft Prioritätsgebühren ab und bestätigt. Bauen Sie keine `ComputeBudget` Anweisungen manuell — das SDK fügt sie automatisch hinzu. ```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?; ``` ### Verwenden Sie Helius Sender für ultra-niedrige Latenz Für zeitkritische Transaktionen (Arbitrage, Sniping, Liquidationen), verwenden Sie `send_smart_transaction_with_sender`. Es routet durch Helius' Infrastruktur über mehrere Regionen und 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?; ``` ### Verwenden Sie `get_asset_batch` für mehrere Vermögenswerte Wenn Sie mehr als einen Vermögenswert abrufen, bündeln Sie sie. Rufen Sie `get_asset` nicht in einer Schleife auf. ```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?; } ``` ### Verwenden Sie Webhooks anstelle von Polling Führen Sie kein Polling von `get_transactions_for_address` in einer Schleife durch. Verwenden Sie Webhooks für serverseitige Benachrichtigungen. ```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?; ``` ## Paginierung ### Token/Cursor-basiert (RPC V2 Methoden) ```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?; ``` ### Seitenbasiert (DAS API) ```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; } ``` ## `token_accounts` Filter Beim Abfragen von `get_transactions_for_address` steuert der `token_accounts` Filter, ob die Aktivität des Token-Kontos einbezogen wird: | Wert | Verhalten | Verwenden Sie Wann | | ---------------- | ---------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | | `None` | Nur Transaktionen, die direkt die Adresse betreffen | Sie kümmern sich nur um SOL-Übertragungen und Programmaufrufe | | `BalanceChanged` | Beinhaltet auch Token-Transaktionen, die einen Saldenwechsel bewirkten | **Empfohlen für die meisten Agenten** — zeigt Token-Sende-/-Empfangsvorgänge ohne Rauschen | | `All` | Beinhaltet alle Token-Konto-Transaktionen | Sie benötigen vollständige Token-Aktivität (kann viele Ergebnisse zurückgeben) | ## `changed_since_slot` — Inkrementelles Abrufen von Konten `changed_since_slot` gibt nur Konten zurück, die nach einem bestimmten Slot geändert wurden. Nützlich für Synchronisierungs- oder Indexierungs-Workflows. Unterstützt von `get_program_accounts_v2`, `get_token_accounts_by_owner_v2`, `get_account_info`, `get_multiple_accounts`, `get_program_accounts` und `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?; ``` ## Häufige Fehler 1. **`transaction_details: Some(TransactionDetails::Full)` ist nicht die Standardeinstellung** — Standardmäßig gibt `get_transactions_for_address` nur Signaturen zurück. Setzen Sie `TransactionDetails::Full`, um vollständige Transaktionsdaten zu erhalten. 2. **Fügen Sie keine ComputeBudget-Anweisungen mit `send_smart_transaction` hinzu** — Das SDK fügt sie automatisch hinzu. Ein Hinzufügen eigener Anweisungen verursacht einen `HeliusError::InvalidInput` Fehler. 3. **Prioritätsgebühren sind in Mikrolamports pro Berechnungseinheit** — Nicht in Lamports. Werte von `get_priority_fee_estimate` sind bereits in der richtigen Einheit. 4. **DAS Paginierung ist 1-basiert** — `page: 1` ist die erste Seite, nicht `page: 0`. 5. **`async_connection()` erfordert `new_async` oder `HeliusBuilder`** — Ein Aufruf von `helius.async_connection()` auf einem mit `Helius::new()` erstellten Client gibt `Err(HeliusError::ClientNotInitialized)` zurück. 6. **`get_asset` gibt `Option` zurück** — Eine erfolgreiche Antwort kann dennoch `None` sein, wenn der Vermögenswert nicht existiert. Behandeln Sie das `Option` explizit. 7. **Sender-Tipps sind obligatorisch** — `send_smart_transaction_with_sender` bestimmt und fügt automatisch Tipps hinzu. Minimum 0,0002 SOL (Dual-Modus) oder 0,000005 SOL (nur SWQOS). 8. **TLS-Feature-Flags** — Der Krate-Standard ist `native-tls`. Verwenden Sie `features = ["rustls"]` (und `default-features = false`) für reines Rust-TLS, wenn OpenSSL nicht verfügbar ist. 9. **Setzen Sie die maximal unterstützte Transaktionsversion auf 1, wenn Sie Transaktionen abrufen.** `get_transaction`, `get_block` und `get_transactions_for_address` mit `TransactionDetails::Full` schlagen mit Fehler `-32015` bei Transaktion v1 sonst fehl. Bei v1-Transaktionen ist die Prioritätsgebühr die `transactionConfig.priorityFee` der Nachricht, eine Gesamtsumme in Lamports; es gibt keine ComputeBudget-Anweisungen zum Scannen. Siehe [Unterstützung für Transaktion v1](/docs/de/rpc/transaction-v1). ## Fehlerbehandlung und Wiederholungen Das SDK bietet typisierte Fehler-Varianten über das `HeliusError` Enum, sodass Sie direkt darauf zugreifen können: ```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. */ } } ``` ### Wiederholungsstrategie Wiederholen bei `RateLimitExceeded` und `InternalError` mit exponentiellem Backoff: ```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!() } ``` | Fehler-Variante | HTTP-Status | Aktion | | ------------------- | ----------- | ------------------------------------------- | | `Unauthorized` | 401 | API-Schlüssel prüfen | | `RateLimitExceeded` | 429 | Zurückziehen und erneut versuchen | | `InternalError` | 5xx | Mit exponentiellem Backoff erneut versuchen | | `BadRequest` | 400 | Anforderungsparameter korrigieren | | `NotFound` | 404 | Ressource existiert prüfen | | `Timeout` | — | Timeout erhöhen oder erneut versuchen |