---
title: "TRON-Energie mit Rust kaufen: das TronSave SDK (2026)"
description: "TRON-Energie in Rust kaufen mit dem offiziellen TronSave-Crate: asynchroner reqwest-Client, typisierte Fehler, Retries und Rate Limiting in vier Aufrufen."
url: https://blog.tronsave.io/de/tron-energie-mit-rust-kaufen/
canonical: https://blog.tronsave.io/de/tron-energie-mit-rust-kaufen/
lang: de-DE
datePublished: 2026-11-15T13:57:59+00:00
dateModified: 2026-11-15T13:57:59+00:00
author: TronSave
publisher: TronSave (https://tronsave.io/)
categories:
  - TRON-Ratgeber
keywords: TRON-Energie mit Rust kaufen
translations:
  en: https://blog.tronsave.io/how-to-buy-tron-energy-in-rust-sdk-guide/
  ru: https://blog.tronsave.io/ru/kak-kupit-energiyu-tron-na-rust/
  es: https://blog.tronsave.io/es/comprar-energia-tron-con-rust/
  pt: https://blog.tronsave.io/pt/comprar-energia-tron-com-rust/
  zh: https://blog.tronsave.io/zh/rust-goumai-bochang-nengliang/
---

# TRON-Energie mit Rust kaufen: das TronSave SDK (2026)

Am schnellsten **kaufen Sie TRON-Energie in Rust** mit dem offiziellen TronSave-Crate: `tronsave = "2"` hinzufügen, einen Client erstellen, dann schätzen, bestellen und abfragen. Vier awaitete Aufrufe, ein typisierter Fehler, auf den Sie wirklich matchen können, und Retries sowie Rate Limiting sind bereits erledigt. Dieser Leitfaden deckt die gesamte Integration ab: Installation, Standardwerte, die dokumentierten Fehlercodes und wie die Bestellung bezahlt wird.

## Warum Energie für Rust-Services zählt

Rust steckt genau dort, wo Stablecoins in großem Volumen bewegt werden: Börsen-Backends, Zahlungsdienstleister, Verwahrdienste, Bots mit hohem Durchsatz. Sie alle treffen auf TRON auf dieselbe Rechnung: Jede **USDT (TRC-20)**\-Überweisung verbraucht Energie, und Energie, die Sie nicht halten, wird durch das Verbrennen von TRX zu Protokollpreisen bezahlt. Bei 100 sun pro Energieeinheit sind das rund 6,43 TRX für eine Standardüberweisung (Stand: November 2026) – bei jeder einzelnen Überweisung erneut.

Energie direkt vor einem Auszahlungslauf zu mieten kostet weniger als sie zu verbrennen (am 28. Oktober 2026 etwa ein Drittel weniger bei einer einstündigen Miete und etwa 59 % weniger pro Überweisung bei einer 30-Tage-Miete), und wenn das im Code passiert, füllt sich der Service selbst auf, statt jemanden anzupiepen. Wenn Sie zuerst die Sicht auf Endpunkt-Ebene möchten, lesen Sie unseren [Leitfaden zur API-Automatisierung](https://blog.tronsave.io/de/tron-energie-per-api-kaufen/); hier geht es um denselben Ablauf mit Rust-Typen und `async`.

![Der Energiemarkt, auf dem ein Rust-Service über das TronSave SDK TRON-Energie kauft](https://blog.tronsave.io/wp-content/uploads/2025/09/Energy-rental-interface-on-Tronsave-copy.png)

Das SDK platziert Bestellungen auf demselben Energiemarkt, den auch die Weboberfläche nutzt. Quelle: TronSave

## Was ist das TronSave Rust SDK?

Es ist der offizielle asynchrone Rust-Client für die TronSave-v2-API, veröffentlicht auf [crates.io als `tronsave`](https://crates.io/crates/tronsave) (Version 2.0.0, MIT-Lizenz, Edition 2021, **MSRV 1.75**). Die generierte API-Referenz finden Sie auf [docs.rs](https://docs.rs/tronsave/latest/tronsave/). Es ist einer von fünf offiziellen Clients – TypeScript, Python, Java, PHP und Rust –, die alle dieselben Endpunkte kapseln und an einer gemeinsamen sprachübergreifenden Konformitäts-Testsuite gemessen werden, sodass das Verhalten zwischen ihnen nicht auseinanderläuft.

Das Crate ist bewusst schlank gehalten:

-   **Async auf `tokio`, aufgebaut auf `reqwest` und `serde`.** Jeder Aufruf ist eine `async fn`, die `tronsave::Result<T>` zurückgibt.
-   **rustls statt OpenSSL.** `reqwest` wird mit `default-features = false` und dem Feature `rustls-tls` eingebunden – es muss also kein System-OpenSSL gelinkt werden, genau das, was Sie in einem musl-, Alpine- oder Distroless-Container wollen.
-   **Typisierte DTOs.** `UserInfo`, `EstimateBuyResource`, `Order`, `Delegate`, `OrderBookLevel` sind einfache `serde`\-Structs, das camelCase-Mapping ist bereits erledigt.
-   **Kleiner Abhängigkeitsbaum.** `reqwest`, `serde`, `serde_json`, `thiserror`, `fastrand` und `tokio` (nur die Features `time` und `sync`).

## Installation

```
[dependencies]
tronsave = "2"
tokio = { version = "1", features = ["full"] }
```

Setzen Sie anschließend `TRONSAVE_API_KEY` in Ihrer Umgebung. `Network::Testnet` richtet den Client auf die Nile-Test-API aus, wo nichts echte TRX kostet; `Network::Mainnet` geht live. Beide ermitteln ihre Basis-URL selbst über `Network::base_url()`, sodass in Ihrer Konfiguration nie ein Hostname fest eingetragen ist.

Dasselbe Enum stellt `fund_address()` bereit, die Einzahlungsadresse für den Ablauf mit signierter Transaktion. Sie aus dem Enum zu lesen, statt einen String in Ihre Konfiguration zu kopieren, ist die sicherere Gewohnheit – eine aus einer Chatnachricht oder einem Suchergebnis kopierte Einzahlungsadresse ist ein bekannter Weg, eine Aufladung zu verlieren.

## Energie kaufen, von Anfang bis Ende

```
use tronsave::{TronsaveClient, Network, models::BuyParams};

#[tokio::main]
async fn main() -> tronsave::Result<()> {
    let sdk = TronsaveClient::new(
        std::env::var("TRONSAVE_API_KEY").ok(),
        Network::Mainnet,
    )?;

    // 1. Who am I, and can I afford this run?
    let me = sdk.get_user_info().await?;
    println!("balance: {} SUN", me.balance);

    // 2. What will it cost? (no API key needed for this call)
    let est = sdk.estimate_buy_resource(BuyParams {
        receiver: "TFwUFWr3QV376677Z8VWXxGUAMFSrq1MbM".into(),
        resource_amount: 65_000,          // ENERGY must be > 64_000
        duration_sec: Some(3600),
        ..Default::default()
    }).await?;
    println!("estimate: {} SUN", est.estimate_trx);

    // 3. Place the order.
    let order = sdk.buy_resource(BuyParams {
        receiver: "TFwUFWr3QV376677Z8VWXxGUAMFSrq1MbM".into(),
        resource_amount: 65_000,
        duration_sec: Some(3600),
        ..Default::default()
    }).await?;

    // 4. Poll until the energy is actually delegated.
    let status = sdk.get_order(&order.order_id).await?;
    println!("{}% filled, {} left", status.fulfilled_percent, status.remain_amount);
    for d in &status.delegates {
        println!("  {} sent {} (tx {})", d.delegator, d.amount, d.txid);
    }
    Ok(())
}
```

Drei Dinge darin verdienen besondere Erwähnung.

**`..Default::default()` ist die ganze Ergonomie.** `BuyParams` hat neun Felder, aber nur zwei sind Pflicht; der Rest sind `Option`s, die bei der Serialisierung komplett weggelassen werden, wenn sie nicht gesetzt sind. Sie benennen, was Sie meinen, und die Standardwerte füllen den Rest.

**`estimate_buy_resource` braucht keine Authentifizierung.** Sie können eine Bestellung bepreisen, bevor Sie einen Schlüssel haben, und ein Preisaufruf in einem Hot Path verbraucht nie Ihr Auth-Budget.

**Die Bestellung ist nicht abgeschlossen, wenn `buy_resource` zurückkehrt.** Der Aufruf liefert eine `order_id`; die Delegierung kommt einige Sekunden später an. Fragen Sie `get_order` ab, bis `fulfilled_percent` 100 erreicht, bevor Sie die Überweisung senden, die die Energie braucht – und prüfen Sie das wirklich, denn eine Teilausführung reicht möglicherweise nicht aus.

## Standardwerte und Limits, die Sie kennen sollten

| Verhalten | Wert |
| --- | --- |
| Standard-Ressourcentyp | `ENERGY` |
| Standard-Preisstufe | `MEDIUM` (auch `FAST`, `SLOW` oder ein direkter Preis in SUN) |
| Standard-Laufzeit | `259_200` Sekunden – 3 Tage |
| Mindestmenge pro Energie-Bestellung | Muss **größer als 64.000** sein |
| Clientseitiges Rate Limit | 15 Anfragen/Sekunde; 1/Sekunde für `get_extendable_delegates` |
| Standard-Timeout / Retries | 30.000 ms / 3 Retries |
| Format von `extend_to` | Unix-Zeitstempel in **Sekunden** |
| Standard-Seitengröße | `10` |

Das Minimum von 64.000 wird geprüft, *bevor* die Anfrage Ihren Prozess verlässt, sodass eine fehlerhafte Schleife ihr Rate Limit nicht damit verbraucht, dieselbe Ablehnung immer wieder neu zu entdecken. Der Rate Limiter ist ein Token Bucket pro Endpunkt, der Ihre eigenen Aufrufe taktet, statt auf eine Abmahnung per 429 zu warten. Und wenn ein Retry angebracht ist, ist der Backoff exponentiell mit **Full Jitter** – 300 ms, pro Versuch verdoppelt, gedeckelt bei 10 Sekunden und dann über dieses gesamte Fenster zufällig verteilt. Der letzte Teil ist wichtiger, als er klingt: Ohne Jitter versucht eine Flotte von Workern, die alle im selben Moment ein 429 bekommen, es im Gleichschritt erneut und überrennt den Endpunkt wieder.

Retries greifen bei 408, 425, 429, 500, 502, 503 und 504 und berücksichtigen einen `Retry-After`\-Header, wenn der Server einen sendet.

## Ein Fehlertyp, sechs Arten

Rust kennt keine Exception-Hierarchien, und das SDK tut auch nicht so. Jeder Aufruf gibt `tronsave::Result<T>` zurück, und die einzige `Error`\-Struct enthält eine `kind`, einen dokumentierten `code`, den HTTP-`status`, `retry_after_ms` und den `raw`\-Body zum Debuggen. Sie matchen darauf:

```
use tronsave::ErrorKind;

match sdk.buy_resource(params).await {
    Ok(order) => tracing::info!(order_id = %order.order_id, "energy ordered"),

    Err(e) if e.kind == ErrorKind::RateLimit => {
        let wait = e.retry_after_ms.unwrap_or(1_000);
        tokio::time::sleep(std::time::Duration::from_millis(wait)).await;
    }

    Err(e) if e.kind == ErrorKind::Business => match e.code.as_str() {
        "INTERNAL_BALANCE_ACCOUNT_TOO_LOW" => top_up_and_alert().await,
        "PRICE_EXCEED_MAX_PRICE_REQUIRED" => skip_until_price_falls(),
        "CANNOT_FULFILLED" => queue_for_retry(),
        _ => tracing::warn!(code = %e.code, "order rejected"),
    },

    Err(e) => tracing::error!(code = %e.code, kind = ?e.kind, status = ?e.status, "buy failed"),
}
```

Die `kind` nennt Ihnen die Klasse des Problems. Der `code` sagt Ihnen, was tatsächlich passiert ist – und anders als eine Freitextmeldung ist er ein dokumentierter, stabiler Wert, der in allen fünf SDKs gleich ist:

| Art | Codes | Was das für Ihren Code bedeutet |
| --- | --- | --- |
| `Auth` | `API_KEY_REQUIRED`, `INVALID_API_KEY` | Schlüssel korrigieren. Nie wiederholen. |
| `Validation` | `MISSING_PARAMS`, `INVALID_PARAMS`, `MIN_PRICE_INVALID` | Aufruf korrigieren. Nie wiederholen. |
| `Business` | `INTERNAL_ACCOUNT_NOT_FOUND`, `INTERNAL_BALANCE_ACCOUNT_TOO_LOW`, `CANNOT_FULFILLED`, `MUST_BE_WAIT_PREVIOUS_ORDER_FILLED`, `PRICE_EXCEED_MAX_PRICE_REQUIRED`, `SOME_DELEGATE_CANNOT_EXTEND` | Die Anfrage war gültig, wurde aber abgelehnt. Nach Code verzweigen. |
| `RateLimit` | `RATE_LIMIT` | `retry_after_ms` abwarten. |
| `Network` | `NETWORK_ERROR` | Transportfehler. Wiederholen ist sicher. |
| `Unknown` | `UNKNOWN` | Unbekannte Antwort. `raw` loggen. |

An diese Business-Codes lohnt es sich, echtes Verhalten zu knüpfen. `INTERNAL_BALANCE_ACCOUNT_TOO_LOW` heißt: aufladen. `PRICE_EXCEED_MAX_PRICE_REQUIRED` heißt, der Markt hat die von Ihnen gesetzte Obergrenze überschritten, und Sie sollten warten, statt sie blind anzuheben. `MUST_BE_WAIT_PREVIOUS_ORDER_FILLED` heißt, dass Sie Bestellungen schneller nachschieben, als sie abgewickelt werden.

## Wie die Bestellung bezahlt wird

Der Client wählt den Zahlungsweg anhand dessen, was Sie übergeben:

-   **Prepaid-Guthaben (empfohlen für Server).** Lassen Sie `signed_tx` auf `None`, dann authentifiziert sich die Bestellung mit Ihrem API-Schlüssel und wird mit Ihrem TronSave-Guthaben verrechnet. Ihr privater TRON-Schlüssel gelangt nie in den Service.
-   **On-Chain pro Bestellung.** Übergeben Sie eine `signed_tx`, die Sie selbst erstellt und signiert haben, und diese Transaktion bezahlt die Bestellung.

Es gibt außerdem einen Helfer `get_signed_transaction()`, der serverseitig signiert. Sein eigener Doc-Kommentar rät, lokal zu signieren, und darauf sollten Sie hören – dieser Aufruf schickt einen privaten Schlüssel über das Netz. Für einen Backend-Service ist der Prepaid-Weg sowohl einfacher als auch sicherer.

## Verlängern statt neu kaufen

Wenn eine Delegierung, die Sie bereits halten, kurz vor dem Ablauf steht, ist Verlängern besser als eine neue Bestellung. Rufen Sie `get_extendable_delegates` mit einem Empfänger und einem Unix-Zeitstempel `extend_to` auf; die Antwort enthält `is_able_to_extend`, `total_estimate_trx` und eine `extend_data`\-Nutzlast, die Sie direkt an `extend_request` übergeben. Beachten Sie das Limit von einem Aufruf pro Sekunde für diesen ersten Aufruf – es ist der eine Endpunkt, den das SDK stärker drosselt als die anderen. Unser [Leitfaden zur Extend-Funktion](https://blog.tronsave.io/de/extend-funktion-tron-energie-verlaengern-aufstocken/) erklärt, wann Verlängern die bessere Wahl ist.

## FAQ

### Welche Rust-Version brauche ich?

1.75 oder neuer – das ist die deklarierte MSRV des Crates, mit Edition 2021.

### Erzwingt es eine bestimmte Async-Runtime?

Es nutzt `tokio` für Timer und Synchronisierung, daher ist tokio die unterstützte Runtime. Nur die Features `time` und `sync` werden als echte Abhängigkeiten eingebunden; das Feature `full` im Installations-Snippet dient nur Ihrem eigenen `#[tokio::main]`.

### Zieht es OpenSSL in meinen Build?

Nein. `reqwest` ist mit `default-features = false` und `rustls-tls` konfiguriert, TLS ist also reines Rust. Deshalb läuft es problemlos auf musl und in Distroless-Images.

### Kann ich testen, ohne echte TRX auszugeben?

Ja – erstellen Sie den Client mit `Network::Testnet` für das Nile-Testnetz auf einem separaten API-Host. Ändern Sie diesen einen Enum-Wert, um live zu gehen.

### Wie viel Energie sollte ich für eine USDT-Überweisung kaufen?

Rund 65.000, wenn der Empfänger bereits USDT hält, etwa 130.000, wenn er nie welche hatte – siehe [wie viel Energie eine USDT-Überweisung braucht](https://blog.tronsave.io/de/wie-viel-energie-usdt-ueberweisung/). Da das Minimum *größer als* 64.000 sein muss, ist 65.000 die kleinste praktikable Energie-Bestellung.

### Hinkt der Rust-Client den anderen hinterher?

Nein. Alle fünf SDKs zielen auf v2 in derselben Version und teilen eine Konformitäts-Testsuite. Wenn Sie mit mehreren Sprachen arbeiten, beschreiben der [TypeScript-Leitfaden](https://blog.tronsave.io/de/tron-energie-per-code-kaufen-tronsave-sdk/) und der [PHP-Leitfaden](https://blog.tronsave.io/how-to-buy-tron-energy-in-php-sdk-guide/) denselben Ablauf.

## Fazit

Wenn Ihr Rust-Service USDT auf TRON bewegt, ist Energie ein laufender Kostenfaktor, den Sie durch Mieten statt Verbrennen deutlich senken können, und das Crate macht daraus eine Integration mit vier Aufrufen statt eines Projekts. Abhängigkeit hinzufügen, die Bestellung ohne Schlüssel bepreisen, gegen Ihr Prepaid-Guthaben kaufen, damit kein privater Schlüssel den Service berührt, auf `ErrorKind` matchen für die Fälle, die echte Behandlung brauchen, und bis 100 % abfragen, bevor Sie senden.

**Jetzt integrieren:** Fügen Sie `tronsave = "2"` hinzu, holen Sie sich einen Schlüssel im [TronSave-Dashboard](https://tronsave.io/de) und bepreisen Sie Ihre erste Bestellung am [Live-Energiemarkt](https://tronsave.io/de/market).

*Das TronSave SDK wird von TronSave veröffentlicht, dem Herausgeber dieses Blogs. Die hier beschriebenen Versionen, Standardwerte und Limits beziehen sich auf Crate 2.0.0 und können sich in späteren Releases ändern – prüfen Sie crates.io und docs.rs, bevor Sie eine Version festlegen. Dies ist keine Finanzberatung.*
