---
title: Cómo comprar energía TRON en Rust con el SDK de TronSave (2026)
description: "Compra energía TRON en Rust con el crate oficial de TronSave: cliente async con reqwest, errores tipados, reintentos y rate limiting en cuatro llamadas."
url: https://blog.tronsave.io/es/comprar-energia-tron-con-rust/
canonical: https://blog.tronsave.io/es/comprar-energia-tron-con-rust/
lang: es-ES
datePublished: 2026-11-15T13:58:00+00:00
dateModified: 2026-11-15T13:58:00+00:00
author: TronSave
publisher: TronSave (https://tronsave.io/)
categories:
  - Guías de TRON
keywords: comprar energía TRON en Rust
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/
  pt: https://blog.tronsave.io/pt/comprar-energia-tron-com-rust/
  zh: https://blog.tronsave.io/zh/rust-goumai-bochang-nengliang/
  de: https://blog.tronsave.io/de/tron-energie-mit-rust-kaufen/
---

# Cómo comprar energía TRON en Rust con el SDK de TronSave (2026)

La forma más rápida de **comprar energía TRON en Rust** es el crate oficial de TronSave: agregas `tronsave = "2"`, creas un cliente y luego estimas, ordenas y consultas. Cuatro llamadas con await, un error tipado sobre el que realmente puedes hacer match, y los reintentos y el rate limiting ya resueltos. Esta guía cubre toda la integración: instalación, valores por defecto, los códigos de error documentados y cómo se paga la orden.

## Por qué la energía importa a los servicios en Rust

Rust aparece justo en los lugares que mueven stablecoins en volumen: backends de exchanges, procesadores de pagos, servicios de custodia, bots de alto rendimiento. Todos chocan con la misma aritmética en TRON: cada transferencia de **USDT (TRC-20)** consume energía, y la energía que no tienes se paga quemando TRX a tarifas del protocolo. A 100 sun por unidad de energía, son unos 6,43 TRX por una transferencia estándar (a noviembre de 2026), y se paga de nuevo en cada envío.

Alquilar la energía justo antes de una tanda de pagos cuesta menos que quemarla (el 28 de octubre de 2026, alrededor de un tercio menos con un alquiler de una hora y cerca de un 59% menos por transferencia con un alquiler de 30 días), y hacerlo desde el código significa que el servicio se recarga solo en lugar de despertar a alguien. Si primero quieres ver el nivel de endpoints, lee nuestra [guía de automatización con la API](https://blog.tronsave.io/es/automatizar-compra-energia-tron-api/); aquí está el mismo flujo con tipos de Rust y `async`.

![El mercado de energía donde un servicio en Rust compra energía TRON mediante el SDK de TronSave](https://blog.tronsave.io/wp-content/uploads/2025/09/Energy-rental-interface-on-Tronsave-copy.png)

El SDK coloca órdenes en el mismo mercado de energía que usa la interfaz web. Fuente: TronSave

## ¿Qué es el SDK de TronSave para Rust?

Es el cliente oficial asíncrono en Rust para la API v2 de TronSave, publicado en [crates.io como `tronsave`](https://crates.io/crates/tronsave) (versión 2.0.0, licencia MIT, edition 2021, **MSRV 1.75**). La referencia de la API generada está en [docs.rs](https://docs.rs/tronsave/latest/tronsave/). Es uno de cinco clientes oficiales (TypeScript, Python, Java, PHP y Rust), que envuelven los mismos endpoints y se validan contra una suite de conformidad común entre lenguajes, así que el comportamiento no se desvía entre ellos.

El crate es deliberadamente ligero:

-   **Async sobre `tokio`, construido con `reqwest` y `serde`.** Cada llamada es una `async fn` que devuelve `tronsave::Result<T>`.
-   **rustls, no OpenSSL.** `reqwest` se incluye con `default-features = false` y la feature `rustls-tls`, así que no hay OpenSSL del sistema que enlazar, justo lo que quieres en un contenedor musl, Alpine o distroless.
-   **DTOs tipados.** `UserInfo`, `EstimateBuyResource`, `Order`, `Delegate` y `OrderBookLevel` son structs `serde` simples con el mapeo a camelCase ya hecho.
-   **Árbol de dependencias pequeño.** `reqwest`, `serde`, `serde_json`, `thiserror`, `fastrand` y `tokio` (solo las features `time` y `sync`).

## Instalación

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

Después define `TRONSAVE_API_KEY` en tu entorno. `Network::Testnet` apunta el cliente a la API de prueba Nile, donde nada cuesta TRX reales; `Network::Mainnet` opera en real. Ambos resuelven su propia URL base con `Network::base_url()`, así que nunca hay un hostname fijo en tu configuración.

El mismo enum expone `fund_address()`, la dirección de depósito para el flujo con transacción firmada. Leerla desde el enum en lugar de pegar un string en tu configuración es el hábito más seguro: una dirección de depósito copiada de un mensaje de chat o de un resultado de búsqueda es una forma muy conocida de perder una recarga.

## Comprar energía de principio a fin

```
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(())
}
```

Hay tres cosas que vale la pena destacar.

**`..Default::default()` es toda la ergonomía.** `BuyParams` tiene nueve campos, pero solo dos son obligatorios; el resto son `Option`s que se omiten por completo al serializar si no se definen. Nombras lo que quieres y los valores por defecto completan lo demás.

**`estimate_buy_resource` no requiere autenticación.** Puedes cotizar una orden antes de tener una clave, y una llamada de precio en un hot path nunca gasta tu presupuesto de autenticación.

**La orden no está terminada cuando `buy_resource` retorna.** Devuelve un `order_id`; la delegación llega unos segundos después. Consulta `get_order` hasta que `fulfilled_percent` llegue a 100 antes de transmitir la transferencia que necesita la energía, y compruébalo, porque un llenado parcial puede no alcanzarte.

## Valores por defecto y límites que conviene conocer

| Comportamiento | Valor |
| --- | --- |
| Tipo de recurso por defecto | `ENERGY` |
| Nivel de precio por defecto | `MEDIUM` (también `FAST`, `SLOW` o un precio directo en SUN) |
| Duración por defecto | `259_200` segundos: 3 días |
| Orden mínima de energía | Debe ser **mayor que 64.000** |
| Rate limit del lado del cliente | 15 solicitudes/segundo; 1/segundo para `get_extendable_delegates` |
| Timeout / reintentos por defecto | 30.000 ms / 3 reintentos |
| Formato de `extend_to` | Timestamp Unix en **segundos** |
| Tamaño de página por defecto | `10` |

El mínimo de 64.000 se verifica *antes* de que la solicitud salga de tu proceso, así que un bucle defectuoso no puede gastar su rate limit redescubriendo el mismo rechazo. El rate limiter es un token bucket por endpoint que regula tus propias llamadas en lugar de esperar a que un 429 te lo recuerde. Y cuando corresponde un reintento, el backoff es exponencial con **full jitter**: 300 ms que se duplican en cada intento, con un tope de 10 segundos, y luego aleatorizados en toda esa ventana. Esto último importa más de lo que parece: sin jitter, una flota de workers que recibe un 429 en el mismo instante reintenta al unísono y vuelve a saturar el endpoint.

Los reintentos se activan con 408, 425, 429, 500, 502, 503 y 504, y respetan el header `Retry-After` cuando el servidor lo envía.

## Un tipo de error, seis clases

Rust no usa jerarquías de excepciones, y el SDK no finge lo contrario. Cada llamada devuelve `tronsave::Result<T>`, y el único struct `Error` incluye un `kind`, un `code` documentado, el `status` HTTP, `retry_after_ms` y el cuerpo `raw` para depurar. Haces match sobre él:

```
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"),
}
```

El `kind` te dice la clase de problema. El `code` te dice qué pasó realmente y, a diferencia de un mensaje de texto libre, es un valor documentado y estable, compartido por los cinco SDK:

| Clase | Códigos | Qué significa para tu código |
| --- | --- | --- |
| `Auth` | `API_KEY_REQUIRED`, `INVALID_API_KEY` | Corrige la clave. Nunca reintentes. |
| `Validation` | `MISSING_PARAMS`, `INVALID_PARAMS`, `MIN_PRICE_INVALID` | Corrige la llamada. Nunca reintentes. |
| `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` | La solicitud era válida pero fue rechazada. Ramifica según el código. |
| `RateLimit` | `RATE_LIMIT` | Espera `retry_after_ms`. |
| `Network` | `NETWORK_ERROR` | Fallo de transporte. Es seguro reintentar. |
| `Unknown` | `UNKNOWN` | Respuesta no reconocida. Registra `raw`. |

Esos códigos de negocio son los que vale la pena conectar a un comportamiento real. `INTERNAL_BALANCE_ACCOUNT_TOO_LOW` significa recargar. `PRICE_EXCEED_MAX_PRICE_REQUIRED` significa que el mercado superó el tope que fijaste y debes esperar en lugar de subirlo a ciegas. `MUST_BE_WAIT_PREVIOUS_ORDER_FILLED` significa que estás encadenando órdenes más rápido de lo que se liquidan.

## Cómo se paga la orden

El cliente elige la vía de pago según lo que le pases:

-   **Saldo prepago (recomendado para servidores).** Deja `signed_tx` en `None` y la orden se autentica con tu clave de API y se liquida contra tu saldo en TronSave. Tu clave privada de TRON nunca entra en el servicio.
-   **On-chain por orden.** Proporciona una `signed_tx` que tú mismo construiste y firmaste, y esa transacción paga la orden.

También existe un helper `get_signed_transaction()` que firma del lado del servidor. Su propio comentario de documentación recomienda firmar localmente, y deberías hacerle caso: esa llamada envía una clave privada por la red. Para un servicio backend, la vía prepago es más simple y más segura.

## Extender en lugar de volver a comprar

Cuando una delegación que ya tienes está por vencer, extenderla es mejor que comprar una orden nueva. Llama a `get_extendable_delegates` con un receptor y un timestamp Unix `extend_to`; devuelve `is_able_to_extend`, `total_estimate_trx` y un payload `extend_data` que pasas directamente a `extend_request`. Ten en cuenta el límite de 1 por segundo en esa primera llamada: es el único endpoint que el SDK regula con más rigor que el resto. Nuestra [guía de la función Extend](https://blog.tronsave.io/es/funcion-extend-ampliar-recargar-energia-tron/) explica cuándo conviene extender.

## Preguntas frecuentes (FAQ)

### ¿Qué versión de Rust necesito?

1.75 o posterior: es la MSRV declarada del crate, con edition 2021.

### ¿Obliga a usar un runtime async concreto?

Depende de `tokio` para temporizadores y sincronización, así que tokio es el runtime soportado. Solo las features `time` y `sync` se incluyen como dependencias reales; la feature `full` del fragmento de instalación es solo para tu propio `#[tokio::main]`.

### ¿Mete OpenSSL en mi build?

No. `reqwest` está configurado con `default-features = false` y `rustls-tls`, así que TLS es Rust puro. Por eso funciona sin complicaciones en musl y en imágenes distroless.

### ¿Puedo probar sin gastar TRX reales?

Sí: crea el cliente con `Network::Testnet` para la red de prueba Nile, en un host de API separado. Cambia ese único valor del enum para pasar a producción.

### ¿Cuánta energía debo comprar para una transferencia de USDT?

Unas 65.000 si el destinatario ya tiene USDT, cerca de 130.000 si nunca los tuvo: consulta [cuánta energía necesita una transferencia de USDT](https://blog.tronsave.io/es/cuanta-energia-necesita-una-transferencia-usdt/). Como el mínimo debe ser *mayor que* 64.000, 65.000 es la orden de energía práctica más pequeña.

### ¿El cliente de Rust va por detrás de los demás?

No. Los cinco SDK apuntan a v2 en la misma versión y comparten una suite de conformidad. Si trabajas con varios lenguajes, la [guía de TypeScript](https://blog.tronsave.io/es/comprar-energia-tron-con-codigo-sdk-tronsave/) y la [guía de PHP](https://blog.tronsave.io/how-to-buy-tron-energy-in-php-sdk-guide/) describen el mismo flujo.

## Conclusión

Si tu servicio en Rust mueve USDT en TRON, la energía es un costo recurrente que puedes reducir bastante alquilando en vez de quemando, y el crate convierte eso en una integración de cuatro llamadas en lugar de un proyecto. Agrega la dependencia, cotiza la orden sin clave, compra contra tu saldo prepago para que ninguna clave privada toque el servicio, haz match sobre `ErrorKind` en los casos que necesitan manejo real y consulta hasta el 100% antes de enviar.

**Empieza a integrar:** agrega `tronsave = "2"`, obtén una clave en el [panel de TronSave](https://tronsave.io/es) y cotiza tu primera orden en [el mercado de energía en vivo](https://tronsave.io/es/market).

*El SDK de TronSave lo publica TronSave, editor de este blog. Las versiones, valores por defecto y límites descritos aquí corresponden al crate 2.0.0 y pueden cambiar en versiones posteriores; revisa crates.io y docs.rs antes de fijar una versión. Esto no es asesoramiento financiero.*
