Lamports en Solana: unidades, comisiones, renta y manejo exacto de enteros

Alcance y el modelo de unidad lamport

Un lamport es la unidad más pequeña de SOL, la moneda nativa de Solana. La proporción es fija: 1 SOL equivale a 1.000.000.000 lamports, o 10^9. Un lamport es 0,000000001 SOL. La unidad lleva el nombre de Leslie Lamport, cuyo trabajo sobre sistemas distribuidos y relojes lógicos influyó en el diseño de los sistemas de consenso y ordenamiento utilizados en las blockchains.

La consecuencia práctica es que cada cantidad en cadena que lees o escribes es un número entero de lamports. Las interfaces de billetera pueden mostrar SOL con hasta nueve decimales, pero el libro mayor subyacente almacena enteros. Las comisiones de transacción, las comisiones prioritarias, los saldos de cuenta y los umbrales de exención de renta se expresan en lamports. Cuando construyes una transacción, pasas enteros de lamports al SDK; cuando consultas un nodo RPC, recibes enteros de lamports de vuelta.

Este artículo asume que tienes disponible un endpoint RPC de Solana y familiaridad básica con JSON-RPC o uno de los SDK de Solana. Se centra en la mecánica de las unidades y los procedimientos de verificación más que en elegir un proveedor específico. Si necesitas una recomendación concreta de endpoint para la mainnet, testnet o devnet de Solana, la guía del Asistente RPC sobre el mejor proveedor RPC de Solana cubre esa decisión por separado.

• 1 SOL = 1.000.000.000 lamports (proporción exacta y fija).
• 1 lamport = 0,000000001 SOL.
• Los saldos, las comisiones y los umbrales de renta son enteros en lamports en cadena.
• Las capas de visualización convierten a SOL; la lógica del programa debe permanecer en lamports.

Por qué las unidades enteras importan para la corrección

Los números de punto flotante no pueden representar exactamente la mayoría de las fracciones decimales. Si almacenas 0,1 SOL como flotante y multiplicas por 10^9, puedes obtener 100000000.00000001 o un valor que se redondea de forma impredecible según el lenguaje y la plataforma. Los programas en cadena evitan esto operando exclusivamente con enteros. Tu código cliente debería hacer lo mismo siempre que construya o compare cantidades.

El patrón seguro es mantener los valores de lamports como enteros de principio a fin. Convierte la entrada de SOL orientada al usuario a lamports una vez, en el límite, usando un análisis que tenga en cuenta los decimales en lugar de punto flotante binario. Vuelve a convertir a SOL solo para visualización. Esto evita errores de un lamport que pueden hacer que una transferencia falle una verificación de saldo o deje una cuenta justo por debajo de su umbral de exención de renta.

La misma disciplina se aplica al cálculo de comisiones. Una comisión base más una comisión prioritaria es una suma entera de lamports. Si la calculas en punto flotante y truncas, puedes pagar de menos y hacer que se rechace una transacción, o pagar de más ligeramente en cada transacción.

Leer lamports de las respuestas RPC

El método getBalance devuelve un objeto de contexto y un campo value que es un número entero de lamports. El método getAccountInfo devuelve lamports en el campo lamports de la cuenta junto con data, owner, executable y rentEpoch. Estas son las fuentes canónicas para los saldos; no infieras saldos a partir de cantidades de tokens ni de cadenas de visualización.

La siguiente llamada curl consulta un saldo. Reemplaza RPC_URL con tu endpoint y la pubkey con la cuenta que deseas inspeccionar. El valor de la respuesta está en lamports, no en SOL.

• getBalance devuelve value como un recuento entero de lamports.
• getAccountInfo devuelve lamports más la longitud de data de la cuenta y su owner.
• Los niveles de commitment afectan a qué slot refleja el saldo; confirmed es un valor predeterminado común para lecturas.

curl -s RPC_URL -H 'Content-Type: application/json' -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getBalance",
  "params": [
    "YOUR_ACCOUNT_PUBKEY",
    {"commitment": "confirmed"}
  ]
}'

Resultado de verificación esperado y una tabla de conversión

Después de ejecutar la consulta de saldo, divide el entero devuelto por 10^9 para obtener SOL para visualización. Por ejemplo, un valor de 5000000 lamports es 0,005 SOL. Un valor de 1000000000 es exactamente 1 SOL. La tabla siguiente muestra la relación para cantidades comunes; completa tus propios valores medidos desde tu endpoint en lugar de suponerlos.

• | Lamports | SOL | Significado típico |
• | --- | --- | --- |
• | 1 | 0,000000001 | Unidad más pequeña |
• | 5000 | 0,000005 | Comisión base para una transacción simple (valor predeterminado documentado) |
• | 10000 | 0,00001 | Ejemplo de una comisión prioritaria pequeña |
• | 1000000000 | 1 | Un SOL |
• | Valor medido de getBalance | Dividir por 10^9 | El saldo de tu cuenta |

Comisiones y comisiones prioritarias en lamports

Las comisiones de transacción de Solana se fijan en lamports. La comisión base documentada para una transacción simple es de 5.000 lamports, que son 0,000005 SOL. Las comisiones prioritarias son lamports adicionales pagados por unidad de cómputo, establecidos por las instrucciones de presupuesto de cómputo de la transacción. La comisión total es la comisión base más la comisión prioritaria, ambas enteras.

Cuando inspeccionas una transacción confirmada, el campo meta.fee informa la comisión realmente cobrada, en lamports. Ese es el número autoritativo para conciliar con tu propia contabilidad. No asumas solo la comisión base; las comisiones prioritarias y cualquier otro componente de comisión se incluyen en meta.fee.

El siguiente ejemplo de JavaScript utiliza la biblioteca web3.js de Solana para convertir SOL a lamports con aritmética entera y leer un saldo. Utiliza LAMPORTS_PER_SOL, que se define como 1.000.000.000. Reemplaza RPC_URL y la clave pública con tus propios valores.

import { Connection, LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';

const connection = new Connection('RPC_URL', 'confirmed');
const account = new PublicKey('YOUR_ACCOUNT_PUBKEY');

// Integer conversion: parse SOL string to lamports without float drift.
function solToLamports(solString) {
  const [whole, frac = ''] = solString.split('.');
  const fracPadded = (frac + '000000000').slice(0, 9);
  return BigInt(whole) * BigInt(LAMPORTS_PER_SOL) + BigInt(fracPadded);
}

const lamports = solToLamports('0.005');
console.log('lamports:', lamports.toString()); // 5000000

const balance = await connection.getBalance(account);
console.log('balance lamports:', balance);
console.log('balance SOL:', balance / LAMPORTS_PER_SOL);

Reservas exentas de renta y creación de cuentas

Las cuentas de Solana deben mantener un saldo mínimo para permanecer abiertas, llamado reserva exenta de renta. El umbral se calcula en lamports según el número de bytes que almacena la cuenta. Cuando creas una cuenta de token o una cuenta de datos de programa, la financias con suficientes lamports para cumplir ese umbral. Si se cierra una cuenta, sus lamports restantes se devuelven al destinatario designado.

La reserva exacta depende del tamaño de la cuenta y de los parámetros actuales. No codifiques un único número para todos los tipos de cuenta. En su lugar, consulta el saldo mínimo para la exención de renta para la longitud de datos específica usando getMinimumBalanceForRentExemption, que devuelve lamports. Esta es la forma correcta de dimensionar la financiación para una nueva cuenta.

Un modo de fallo común es financiar una cuenta con un poco menos que el mínimo exento de renta debido a un error de redondeo en la conversión de SOL a lamport. La creación de la cuenta entonces falla o la cuenta queda sujeta a cobro de renta. Calcula siempre la reserva en lamports y compara enteros.

curl -s RPC_URL -H 'Content-Type: application/json' -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getMinimumBalanceForRentExemption",
  "params": [165, {"commitment": "confirmed"}]
}'

Un procedimiento de diagnóstico para discrepancias de lamports

Cuando una transferencia falla con un error de fondos insuficientes, o cuando una cuenta se cierra inesperadamente, revisa los valores de lamports en orden. Este procedimiento aísla si el problema es un déficit de saldo, un cálculo erróneo de comisiones o un problema de umbral de exención de renta.

Primero, consulta el saldo del remitente con getBalance y registra el entero. Segundo, consulta la cuenta del destinatario con getAccountInfo para ver si existe y cuáles son sus lamports y longitud de datos. Tercero, consulta getMinimumBalanceForRentExemption para la longitud de datos del destinatario si la estás creando. Cuarto, inspecciona meta.fee y los logs de la transacción fallida si hay una firma disponible. Compara la suma del importe de transferencia más la comisión más cualquier financiación de renta contra el saldo del remitente como enteros.

El ejemplo de Python a continuación realiza las tres primeras comprobaciones. Utiliza la biblioteca estándar y una llamada JSON-RPC, por lo que no tiene dependencia de SDK. Reemplaza RPC_URL y las claves públicas con tus propios valores.

import json, urllib.request

RPC_URL = 'RPC_URL'

def rpc(method, params):
    body = json.dumps({'jsonrpc': '2.0', 'id': 1, 'method': method, 'params': params}).encode()
    req = urllib.request.Request(RPC_URL, data=body, headers={'Content-Type': 'application/json'})
    with urllib.request.urlopen(req) as resp:
        return json.loads(resp.read())

sender = 'SENDER_PUBKEY'
recipient = 'RECIPIENT_PUBKEY'

balance = rpc('getBalance', [sender, {'commitment': 'confirmed'}])['result']['value']
print('sender lamports:', balance)

info = rpc('getAccountInfo', [recipient, {'encoding': 'base64', 'commitment': 'confirmed'}])['result']['value']
if info is None:
    print('recipient does not exist; rent funding required')
else:
    data_len = len(info['data'][0]) if isinstance(info['data'], list) else 0
    print('recipient lamports:', info['lamports'], 'data bytes:', data_len)
    reserve = rpc('getMinimumBalanceForRentExemption', [data_len, {'commitment': 'confirmed'}])['result']
    print('rent-exempt minimum lamports:', reserve)

Solución de errores comunes de lamports

Varios patrones de fallo se repiten cuando los equipos trabajan por primera vez con lamports. Reconocerlos acorta la depuración.

Desviación por redondeo: convertir SOL a lamports con punto flotante y truncar puede producir un valor un lamport por debajo. Usa análisis de cadenas o decimales y aritmética entera. Renta insuficiente: crear una cuenta con menos del mínimo exento de renta para su longitud de datos causa fallo o cobro de renta. Consulta el mínimo para la longitud exacta en bytes. Subestimación de comisiones: asumir solo la comisión base cuando se establecen comisiones prioritarias lleva a transacciones rechazadas. Lee meta.fee de una transacción confirmada para ver el cargo real. Commitment incorrecto: leer un saldo con commitment processed puede mostrar un estado que luego se revierte. Usa confirmed o finalized para decisiones que muevan fondos.

Si estás probando contra un clúster que no es mainnet, confirma que tu endpoint sirve el clúster que esperas. La guía de Solana devnet cubre la selección de clúster y los flujos de trabajo con faucet. Para lecturas y escrituras en producción, la fiabilidad del endpoint y los límites de tasa importan; la comparación de proveedores RPC de Solana y la página de precios RPC te ayudan a dimensionar esa elección.

• Usa análisis de enteros o decimales, nunca flotantes binarios, para la conversión de SOL a lamport.
• Consulta getMinimumBalanceForRentExemption para la longitud exacta de datos de la cuenta.
• Concilia contra meta.fee, no contra una comisión base supuesta.
• Usa commitment confirmed o finalized para decisiones sensibles al saldo.

Limitaciones y compensaciones

Trabajar en lamports es exacto pero verboso. Las interfaces de usuario deben formatear enteros grandes en cadenas SOL, y el tipo Number de JavaScript solo es seguro hasta 2^53, que son aproximadamente 9 millones de SOL en lamports. Para saldos o totales que puedan superar eso, usa BigInt o una biblioteca decimal. Esta es una restricción real para cuentas de tesorería y propiedad de programas.

Los umbrales de exención de renta y los parámetros de comisiones son parámetros de red que pueden cambiar. Codificarlos en servicios de larga duración crea riesgo de mantenimiento. Prefiere consultar la cadena para los valores que necesitas en el momento en que los necesitas, y almacena en caché con un tiempo de vida corto.

Finalmente, los lamports no son un token que puedas intercambiar de forma independiente; son la unidad contable de SOL. Las herramientas que muestran un precio o mercado separado de 'lamport' no están describiendo la unidad de Solana. Trata cualquier listado de ese tipo como no relacionado con la unidad de protocolo descrita aquí.

Próximos pasos para integración y operaciones

Una vez que tus conversiones y verificaciones de saldo sean seguras para enteros, el siguiente paso es hacer que tu acceso RPC sea lo suficientemente fiable para el volumen de lectura y escritura que necesitas. Para una elección concreta de endpoint, usa la recomendación del Asistente RPC para el mejor proveedor RPC de Solana. Para cobertura de red y detalles de clúster, consulta la página de redes compatibles. Para rendimiento dedicado y aislamiento, revisa las opciones de nodos dedicados, y para modelado de costos, la página de precios RPC.

Si estás construyendo una integración más amplia, la guía de endpoints RPC multicadena y la guía de Solana devnet proporcionan contexto para probar entre clústeres. Mantén el manejo de lamports en un único módulo de utilidad compartido para que cada servicio convierta y compare cantidades de la misma manera.

• Centraliza la conversión de SOL a lamport y de lamport a SOL en una utilidad probada.
• Usa BigInt o tipos decimales donde los totales puedan superar 2^53 lamports.
• Consulta los mínimos exentos de renta en tiempo de ejecución en lugar de codificarlos.
• Elige un endpoint mediante la guía del Asistente RPC y luego verifica con tus propias mediciones de saldo y comisiones.