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; aquí está el mismo flujo con tipos de Rust y async.

¿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 (versión 2.0.0, licencia MIT, edition 2021, MSRV 1.75). La referencia de la API generada está en docs.rs. 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 conreqwestyserde. Cada llamada es unaasync fnque devuelvetronsave::Result<T>. - rustls, no OpenSSL.
reqwestse incluye condefault-features = falsey la featurerustls-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,DelegateyOrderBookLevelson structsserdesimples con el mapeo a camelCase ya hecho. - Árbol de dependencias pequeño.
reqwest,serde,serde_json,thiserror,fastrandytokio(solo las featurestimeysync).
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 Options 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_txenNoney 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_txque 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 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. 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 y la guía de PHP 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 y cotiza tu primera orden en el mercado de energía en vivo.
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.


