Integra pagos en USDT TRC-20 en TRON
Agrega a tu sitio un formulario de pagos masivos: el remitente conecta su propia billetera, ingresa los destinatarios y los montos en USDT, revisa la comisión y firma el lote. El contrato de pagos de Volet.com envía USDT TRC-20 desde la billetera del remitente directamente a las billeteras de los destinatarios, así que los fondos nunca pasan por una cuenta de Volet.com.
Esta guía cubre TRON Mainnet. Para otras redes, consulta BNB Smart Chain y Ethereum.
Antes de empezar
- Billetera del remitente — TronLink. Los ejemplos usan la extensión TronLink en Google Chrome, que entrega TronWeb a tu página cuando el remitente se conecta.
- Fondos en la billetera del remitente — USDT TRC-20 para los pagos y la comisión de procesamiento, más TRX o Energy y Bandwidth en staking para los costos de red. No necesitas fondear ninguna billetera para crear el formulario: paga el remitente cuando envía un lote.
- Biblioteca — la parte del navegador no requiere instalación: TronLink inyecta TronWeb. El ejemplo de backend usa el paquete npm
tronweb. No se necesita ningún SDK de Volet.com. - Sitio web — servido por HTTPS, o desde
localhostdurante el desarrollo. - Backend y base de datos — para guardar cada lote y verificar los pagos.
- Acceso a la blockchain — un nodo de TRON o un servicio alojado, como TronGrid. Los endpoints públicos de TronGrid pueden requerir una clave de API y limitan la frecuencia de solicitudes.
Cómo funciona
- El remitente completa el formulario de pagos en tu sitio: direcciones de los destinatarios, montos en USDT y, de forma opcional, la dirección de un socio.
- El remitente conecta TronLink. Tu sitio nunca necesita su clave privada.
- Tu frontend valida el lote y obtiene la comisión de procesamiento del contrato con
previewCommission(). - Tu sitio muestra el total de los pagos, la comisión de procesamiento, el total de USDT necesario y una estimación de los costos de red.
- Cuando el remitente confirma, tu frontend revisa el saldo de USDT y la autorización de gasto (allowance). Si la autorización no alcanza, TronLink pide al remitente que firme primero una transacción
approve(). - Tu frontend vuelve a revisar la comisión, la billetera, la red y los destinatarios, y luego TronLink pide al remitente que firme
batchPayout(). - Tu backend guarda el hash de transacción (
txid) y verifica la transferencia de USDT a cada destinatario antes de marcar ese pago como completado.
Si falla el pago a un destinatario, los demás no necesariamente se cancelan, así que una transacción exitosa no prueba que todos hayan cobrado. Consulta Paso 7: Verifica cada pago.
Contrato de pagos
| Valor | |
|---|---|
| Red | TRON Mainnet, chain ID 0x2b6653dc en TronLink |
| Contrato de pagos | THwUFuithr9QuTFa4wBjN2zxFWjUrftV84 (TRONSCAN) |
| Contrato de USDT | TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t |
| Decimales de USDT | 6 (1 USDT = 1.000.000 unidades base) |
| Costos de red pagados en | TRX, o Energy y Bandwidth en staking |
| Dirección cero (sin socio) | T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb |
Antes de pedir una firma, revisa siempre la red activa y el resultado de usdt() del contrato.
El contrato ofrece estas funciones:
function usdt() external view returns (address);
function MAX_BATCH_SIZE() external view returns (uint256);
function paused() external view returns (bool);
function previewCommission(uint256 total, uint256 count)
external view returns (uint256 commission);
function previewCommissionSplit(uint256 total, uint256 count, address whiteLabel)
external view returns (uint256 platformCommission, uint256 partnerShare);
function getPartner(address partner)
external view returns (bool active, uint16 shareBps);
function batchPayout(
address[] calldata recipients,
uint256[] calldata amounts,
address whiteLabel
) external;
Emite los eventos BatchPayout, PayoutFailed, RefundSent, PartnerNotFound y CommissionTransferFailed. PayoutFailed enumera los destinatarios y los montos que no se pagaron.
Los ejemplos de esta página incluyen solo las funciones y los eventos que usan. Antes de integrar, abre el contrato de pagos en TRONSCAN, toma su ABI completo de la pestaña Contract y compara con él las firmas de las funciones, los tipos de parámetros y los eventos de tu código. Antes de enviar fondos reales, compara también con esta página la dirección del token que devuelve usdt(), los resultados de previewCommission() y los eventos del contrato.
Comisiones
La comisión de procesamiento es de 0.1 USDT por destinatario del lote, además de los montos de los pagos. Por ejemplo, un lote que paga 10, 20 y 30 USDT a 3 destinatarios necesita 60 USDT para los pagos y 0.3 USDT para la comisión: 60.3 USDT en total.
Muestra siempre al remitente el valor actual de previewCommission(), no una comisión calculada en tu código.
El remitente también paga los costos de red de TRON (Energy y Bandwidth) de cada transacción: el pago y, cuando hace falta, la aprobación. Se cubren con recursos en staking o con TRX quemados.
Dirección del socio
batchPayout() recibe el argumento whiteLabel para la billetera opcional de un socio que comparte la comisión de procesamiento. Un lote funciona sin socio: pasa la dirección cero de TRON.
Si hay un socio, pasa la dirección de su billetera. getPartner() indica si la dirección es un socio activo y su participación en puntos básicos, y previewCommissionSplit() muestra cómo se reparte la comisión entre Volet.com y el socio. La comisión que paga el remitente no cambia: previewCommission() no depende del socio.
Para registrar la billetera de un socio, escribe a [email protected] con la dirección de la billetera y la red.
Paso 1: Agrega el formulario de pagos
Agrega los controles del formulario a tu página. Cada bloque data-payout-row es un destinatario; agrega o quita bloques para cambiar la cantidad de destinatarios.
<input id="partner-wallet" type="text" placeholder="Partner wallet (optional)">
<div data-payout-row>
<input name="address" type="text" placeholder="Recipient TRON address">
<input name="amount" type="text" placeholder="USDT amount">
</div>
<button id="connect" type="button">Connect TronLink</button>
<button id="preview" type="button">Preview payouts</button>
<button id="send" type="button">Send payouts</button>
<pre id="summary"></pre>
Antes de llevar el formulario a producción, agrega tus propios estilos, la gestión de filas, los indicadores de progreso y el estado deshabilitado de los botones.
Paso 2: Conecta la billetera del remitente
Crea tron-payouts.js, un módulo del navegador, y empiézalo con la configuración del contrato y la función de conexión. Los pasos 3 y 4 agregan código al mismo archivo.
const TRON_MAINNET = '0x2b6653dc';
const PAYOUT_ADDRESS = 'THwUFuithr9QuTFa4wBjN2zxFWjUrftV84';
const USDT_ADDRESS = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
const TRON_ZERO = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';
// A cap of 300 TRX per transaction, not the expected cost.
const FEE_LIMIT_SUN = 300_000_000;
const PAYOUT_ABI = [
{ type: 'function', name: 'usdt', stateMutability: 'pure', inputs: [], outputs: [{ type: 'address' }] },
{ type: 'function', name: 'MAX_BATCH_SIZE', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
{ type: 'function', name: 'paused', stateMutability: 'view', inputs: [], outputs: [{ type: 'bool' }] },
{ type: 'function', name: 'previewCommission', stateMutability: 'view', inputs: [{ type: 'uint256', name: 'total' }, { type: 'uint256', name: 'count' }], outputs: [{ type: 'uint256', name: 'commission' }] },
{ type: 'function', name: 'previewCommissionSplit', stateMutability: 'view', inputs: [{ type: 'uint256', name: 'total' }, { type: 'uint256', name: 'count' }, { type: 'address', name: 'whiteLabel' }], outputs: [{ type: 'uint256', name: 'platformCommission' }, { type: 'uint256', name: 'partnerShare' }] },
{ type: 'function', name: 'getPartner', stateMutability: 'view', inputs: [{ type: 'address', name: 'partner' }], outputs: [{ type: 'bool', name: 'active' }, { type: 'uint16', name: 'shareBps' }] },
{ type: 'function', name: 'batchPayout', stateMutability: 'nonpayable', inputs: [{ type: 'address[]', name: 'recipients' }, { type: 'uint256[]', name: 'amounts' }, { type: 'address', name: 'whiteLabel' }], outputs: [] }
];
const USDT_ABI = [
{ type: 'function', name: 'balanceOf', stateMutability: 'view', inputs: [{ type: 'address', name: 'owner' }], outputs: [{ type: 'uint256' }] },
{ type: 'function', name: 'allowance', stateMutability: 'view', inputs: [{ type: 'address', name: 'owner' }, { type: 'address', name: 'spender' }], outputs: [{ type: 'uint256' }] },
{ type: 'function', name: 'approve', stateMutability: 'nonpayable', inputs: [{ type: 'address', name: 'spender' }, { type: 'uint256', name: 'amount' }], outputs: [{ type: 'bool' }] }
];
export async function connect() {
const wallet = window.tron;
if (!wallet?.isTronLink) throw new Error('Install and unlock TronLink.');
const accounts = await wallet.request({ method: 'eth_requestAccounts' });
// Ask TronLink to select TRON Mainnet; the sender may need to confirm.
await wallet.request({ method: 'wallet_switchEthereumChain', params: [{ chainId: TRON_MAINNET }] });
const tronWeb = wallet.tronWeb;
if (!tronWeb?.ready) throw new Error('TronLink did not provide TronWeb.');
const sender = tronWeb.defaultAddress.base58;
if (!sender || !tronWeb.isAddress(sender) || sender !== accounts[0]) {
throw new Error('Unexpected connected TRON address.');
}
const payout = await tronWeb.contract(PAYOUT_ABI, PAYOUT_ADDRESS);
const token = await tronWeb.contract(USDT_ABI, USDT_ADDRESS);
// Make sure this deployment pays out the expected token. TronWeb may return a hex address.
const tokenFromContract = String(await payout.usdt().call());
const tokenAddress = tokenFromContract.startsWith('0x')
? tronWeb.address.fromHex('41' + tokenFromContract.slice(2))
: tokenFromContract.startsWith('41')
? tronWeb.address.fromHex(tokenFromContract)
: tokenFromContract;
if (tokenAddress !== USDT_ADDRESS) throw new Error('Unexpected USDT token in the payout contract.');
return { wallet, tronWeb, sender, payout, token };
}
// Signatures go only to the wallet and network the batch was reviewed with.
async function assertWalletUnchanged(session) {
await session.wallet.request({ method: 'wallet_switchEthereumChain', params: [{ chainId: TRON_MAINNET }] });
if (session.wallet.tronWeb.defaultAddress.base58 !== session.sender) {
throw new Error('Wallet changed. Connect again and review the batch.');
}
}
Llama a connect() solo cuando el remitente selecciona Connect TronLink, nunca al cargar la página.
Paso 3: Muestra el lote y la comisión
Agrega las funciones de validación y vista previa a tron-payouts.js. quote() convierte las filas del formulario en argumentos del contrato en unidades base de USDT y obtiene la comisión, el saldo y la autorización de gasto.
function toUsdtUnits(text) {
if (typeof text !== 'string' || !/^\d+(\.\d{1,6})?$/.test(text)) {
throw new Error(`Invalid USDT amount: ${text}`);
}
const [whole, fraction = ''] = text.split('.');
const units = BigInt(whole) * 1_000_000n + BigInt(fraction.padEnd(6, '0'));
if (units <= 0n) throw new Error('Each amount must be positive.');
return units;
}
export function formatUsdt(units) {
const fraction = (units % 1_000_000n).toString().padStart(6, '0').replace(/0+$/, '');
return `${units / 1_000_000n}${fraction ? '.' + fraction : ''} USDT`;
}
const toBigInt = (value) => BigInt(value.toString());
export async function quote(session, rows, partnerWallet = null) {
const { tronWeb, sender, payout, token } = session;
if (!Array.isArray(rows) || rows.length === 0) throw new Error('Add at least one recipient.');
if (await payout.paused().call()) throw new Error('The payout contract is paused.');
if (BigInt(rows.length) > toBigInt(await payout.MAX_BATCH_SIZE().call())) {
throw new Error('The batch has more recipients than the contract allows.');
}
const recipients = rows.map((row) => {
if (!row.address.startsWith('T') || !tronWeb.isAddress(row.address) || row.address === TRON_ZERO) {
throw new Error(`Invalid recipient address: ${row.address}`);
}
return row.address;
});
const amounts = rows.map((row) => toUsdtUnits(row.amount));
const whiteLabel = partnerWallet || TRON_ZERO;
if (!tronWeb.isAddress(whiteLabel)) throw new Error('Invalid partner address.');
const total = amounts.reduce((sum, amount) => sum + amount, 0n);
const commission = toBigInt(
await payout.previewCommission(total.toString(), recipients.length).call()
);
const split = await payout.previewCommissionSplit(
total.toString(), recipients.length, whiteLabel
).call();
return {
recipients, amounts, whiteLabel, total, commission,
platformCommission: toBigInt(split.platformCommission),
partnerShare: toBigInt(split.partnerShare),
required: total + commission,
balance: toBigInt(await token.balanceOf(sender).call()),
allowance: toBigInt(await token.allowance(sender, PAYOUT_ADDRESS).call())
};
}
Muestra al remitente total, commission y required, con el formato de formatUsdt(), junto con una estimación de los costos de red. No conviertas montos con aritmética de punto flotante: las unidades base los mantienen exactos.
Un pago enviado a una dirección equivocada no se puede cancelar ni devolver. Muestra al remitente cada dirección y cada monto antes de que firme, y acepta solo direcciones de TRON que puedan recibir USDT TRC-20.
Paso 4: Aprueba USDT y envía el lote
Agrega la función de envío a tron-payouts.js. Comprueba que nada cambió desde que el remitente revisó el lote, pide una aprobación si la autorización de gasto no alcanza, espera a que la aprobación quede solidificada y luego envía batchPayout().
function sameBatch(a, b) {
return a.required === b.required &&
a.whiteLabel === b.whiteLabel &&
a.recipients.length === b.recipients.length &&
a.recipients.every((address, i) => address === b.recipients[i] && a.amounts[i] === b.amounts[i]);
}
async function waitForSolidified(txid) {
for (let attempt = 0; attempt < 30; attempt++) {
const response = await fetch('https://api.trongrid.io/walletsolidity/gettransactioninfobyid', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ value: txid })
});
if (!response.ok) throw new Error('TronGrid is unavailable.');
const info = await response.json();
if (info.id) {
if (info.receipt?.result !== 'SUCCESS') throw new Error('The transaction failed.');
return info;
}
await new Promise((resolve) => setTimeout(resolve, 3000));
}
throw new Error(`Transaction ${txid} is still pending. Check it before retrying.`);
}
export async function send(session, rows, reviewed, partnerWallet = null) {
const { payout, token } = session;
await assertWalletUnchanged(session);
const current = await quote(session, rows, partnerWallet);
if (!sameBatch(current, reviewed)) {
throw new Error('The batch or the fee changed. Review the updated quote.');
}
if (current.balance < current.required) throw new Error('Not enough USDT in the sender wallet.');
if (current.allowance < current.required) {
if (current.allowance > 0n) {
await waitForSolidified(
await token.approve(PAYOUT_ADDRESS, '0').send({ feeLimit: FEE_LIMIT_SUN })
);
}
await waitForSolidified(
await token.approve(PAYOUT_ADDRESS, current.required.toString()).send({ feeLimit: FEE_LIMIT_SUN })
);
}
// The fee can change while the approval confirms. Check again before the payout signature.
await assertWalletUnchanged(session);
const fresh = await quote(session, rows, partnerWallet);
if (!sameBatch(fresh, reviewed) ||
fresh.balance < fresh.required ||
fresh.allowance < fresh.required) {
throw new Error('The fee, balance or allowance changed. Review the batch before retrying.');
}
const txid = await payout.batchPayout(
fresh.recipients, fresh.amounts.map(String), fresh.whiteLabel
).send({ feeLimit: FEE_LIMIT_SUN });
return { txid, explorerUrl: `https://tronscan.org/#/transaction/${txid}` };
}
Según la autorización de gasto existente, el remitente firma de una a tres transacciones:
| Autorización existente | Transacciones a firmar |
|---|---|
| Suficiente para el lote | Pago |
| Cero | Aprobación, pago |
| Distinta de cero pero insuficiente | Restablecer la autorización a cero, aprobación, pago |
La aprobación cubre exactamente el monto de este lote, nunca un monto ilimitado. Cada aprobación debe quedar solidificada antes de la siguiente transacción, lo que suele tardar alrededor de un minuto; una transacción approve() no mueve fondos.
FEE_LIMIT_SUN es lo máximo que una transacción puede gastar en costos de red (300 TRX), no lo que cuesta. Estima la Energy que necesita un lote y fija un tope adecuado.
Paso 5: Conecta los botones
Conecta el módulo con el formulario. Las solicitudes a la billetera parten solo de los clics del remitente, y los destinatarios y los montos siempre salen del formulario.
import { connect, formatUsdt, quote, send } from './tron-payouts.js';
const $ = (selector) => document.querySelector(selector);
let session = null;
let reviewed = null;
function readRows() {
return [...document.querySelectorAll('[data-payout-row]')].map((row) => ({
address: row.querySelector('[name="address"]').value.trim(),
amount: row.querySelector('[name="amount"]').value.trim()
}));
}
function readPartner() {
return $('#partner-wallet').value.trim() || null;
}
function show(text) {
$('#summary').textContent = text;
}
// A quote is valid only for the wallet and network it was made with.
function resetSession() {
session = null;
reviewed = null;
show('Wallet or network changed. Connect again.');
}
window.tron?.on?.('accountsChanged', resetSession);
window.tron?.on?.('chainChanged', resetSession);
async function onConnect() {
session = await connect();
reviewed = null;
show(`Connected: ${session.sender}`);
}
async function onPreview() {
if (!session) throw new Error('Connect TronLink first.');
reviewed = await quote(session, readRows(), readPartner());
show([
`Payouts: ${formatUsdt(reviewed.total)}`,
`Processing fee: ${formatUsdt(reviewed.commission)}`,
`Total required: ${formatUsdt(reviewed.required)}`
].join(' | '));
}
async function onSend() {
if (!session || !reviewed) throw new Error('Connect TronLink and preview the batch first.');
if (!window.confirm('Send this batch? TronLink will ask you to sign each transaction.')) return;
const result = await send(session, readRows(), reviewed, readPartner());
reviewed = null;
show(`Submitted: ${result.explorerUrl}`);
// Send result.txid to your backend together with the batch, then verify it (Step 7).
}
for (const [id, handler] of [['#connect', onConnect], ['#preview', onPreview], ['#send', onSend]]) {
$(id).addEventListener('click', () => {
handler().catch((error) => show(error.message ?? String(error)));
});
}
Si el remitente edita el formulario después de la vista previa, send() se detiene con "The batch or the fee changed" y el remitente vuelve a ver la vista previa.
Paso 6: Registra el lote
Guarda cada lote en tu backend antes de que el remitente lo firme y nunca lo sobrescribas. Conserva:
- tu propio ID de lote
- la red
- la dirección del remitente
- la lista de destinatarios y los montos exactos en unidades base de USDT
- la dirección del socio o la dirección cero de TRON
- la comisión de procesamiento cotizada
- los hashes de las transacciones de aprobación, si las hubo
- el hash de la transacción de pago (
txid) - el estado final de cada destinatario
batchPayout() no acepta un ID de lote, así que el vínculo entre tu lote y su transacción existe solo en tu base de datos. Úsalo para evitar duplicados: si una transacción sigue pendiente, sigue su txid y no vuelvas a enviar el mismo lote.
Paso 7: Verifica cada pago
Un hash de transacción solo muestra que el lote se envió. Un recibo exitoso o un evento BatchPayout tampoco prueban que todos los destinatarios cobraron: si falla el pago a uno, los demás no necesariamente se cancelan, y el contrato lo informa con PayoutFailed y puede reembolsar al remitente con RefundSent.
Tu backend lee los datos solidificados de la transacción desde un SolidityNode:
POST https://api.trongrid.io/walletsolidity/gettransactionbyid
POST https://api.trongrid.io/walletsolidity/gettransactioninfobyid
Ambos reciben el hash de la transacción en el cuerpo: {"value": "<txid>"}.
Luego verifica cada destinatario con los eventos Transfer de USDT de la transacción. El ejemplo de abajo se ejecuta en Node.js con el paquete tronweb. Toma el lote de tu base de datos, no del navegador.
import { TronWeb } from 'tronweb';
const tronWeb = new TronWeb({ fullHost: 'https://api.trongrid.io' });
const PAYOUT_ADDRESS = 'THwUFuithr9QuTFa4wBjN2zxFWjUrftV84';
const USDT_ADDRESS = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
// keccak256('Transfer(address,address,uint256)')
const TRANSFER_TOPIC = 'ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
const hex = (base58) => tronWeb.address.toHex(base58).toLowerCase(); // '41…'
async function solidity(method, txid) {
const response = await fetch(`https://api.trongrid.io/walletsolidity/${method}`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'TRON-PRO-API-KEY': process.env.TRONGRID_API_KEY
},
body: JSON.stringify({ value: txid })
});
if (!response.ok) throw new Error('TronGrid is unavailable.');
return response.json();
}
export async function verifyPayout(batch) {
const [tx, info] = await Promise.all([
solidity('gettransactionbyid', batch.txid),
solidity('gettransactioninfobyid', batch.txid)
]);
if (!info.id) return { status: 'pending' };
if (info.receipt?.result !== 'SUCCESS') return { status: 'failed' };
const call = tx.raw_data?.contract?.[0]?.parameter?.value;
if (call?.owner_address?.toLowerCase() !== hex(batch.sender) ||
call?.contract_address?.toLowerCase() !== hex(PAYOUT_ADDRESS)) {
return { status: 'review', reason: 'Unexpected sender or contract.' };
}
// Log addresses come without the 41 prefix.
const usdtLogAddress = hex(USDT_ADDRESS).slice(2);
const received = new Map();
for (const log of info.log ?? []) {
if (log.address?.toLowerCase() !== usdtLogAddress || log.topics?.[0] !== TRANSFER_TOPIC) continue;
const to = '41' + log.topics[2].slice(24);
received.set(to, (received.get(to) ?? 0n) + BigInt('0x' + log.data));
}
const expected = new Map();
batch.recipients.forEach((address, i) => {
const key = hex(address);
expected.set(key, (expected.get(key) ?? 0n) + BigInt(batch.amounts[i]));
});
const results = [...expected].map(([address, amount]) => ({
address: tronWeb.address.fromHex(address),
expected: amount.toString(),
received: (received.get(address) ?? 0n).toString(),
paid: received.get(address) === amount
}));
return {
status: results.every((result) => result.paid) ? 'paid' : 'partial',
results
};
}
Marca como completados solo los destinatarios con paid: true. Para los demás, busca los eventos PayoutFailed y RefundSent de la transacción, por ejemplo en TRONSCAN, y revisa el saldo del remitente antes de pagarles en un lote nuevo. Nunca reenvíes un lote completo de forma automática.
Una transacción que aún no está solidificada está pendiente, no fallida: deja el lote pendiente y vuelve a intentarlo. Esta verificación cubre las transferencias a los destinatarios. En producción, tu backend también compara los datos de entrada de la transacción con el lote guardado y revisa los eventos del socio y de la comisión. Para saber cómo funciona la solidificación, consulta TRON confirmation semantics.
Notas importantes
- Nunca pidas a los remitentes claves privadas ni frases semilla. Todas las firmas ocurren en TronLink.
- Nunca pidas por defecto una aprobación ilimitada de USDT.
- Antes de cada firma, muestra la dirección del contrato de pagos, los destinatarios, la comisión de procesamiento y la estimación de los costos de red.
- TronLink es el último paso de aprobación. Verificar el resultado es responsabilidad de tu aplicación.
- Las transacciones confirmadas en la blockchain no se pueden cancelar ni revertir.
Si algo sale mal
| Problema | Causa | Qué hacer |
|---|---|---|
| "Install and unlock TronLink" | TronLink no está instalado en el navegador o está bloqueado | Pide al remitente que instale o desbloquee TronLink. |
| TronLink pide cambiar de red | La billetera no está en TRON Mainnet | Pide al remitente que confirme el cambio. No pidas ninguna firma en otra red. |
| El remitente rechaza la conexión, la aprobación o el pago | El remitente canceló la solicitud en TronLink | No envíes el lote y muestra un mensaje claro. |
| "Invalid recipient address" o "Invalid USDT amount" | Una fila del formulario tiene un error | Bloquea la vista previa y el envío hasta que el remitente corrija ese destinatario. |
| "Not enough USDT in the sender wallet" | El saldo es menor que los pagos más la comisión | Muestra el total necesario y los TRX necesarios para los costos de red. |
| Una transacción falla por falta de Energy (out of energy) | El remitente tiene pocos TRX o poca Energy, o el límite de comisión es bajo para el lote | Pide al remitente que agregue TRX o haga staking para obtener Energy, o sube el límite de comisión para lotes grandes. |
| "Transaction is still pending" | La aprobación o el pago aún no están solidificados | Sigue el txid original. No vuelvas a transmitir la misma transacción. |
| La transacción fue exitosa, pero un destinatario no tiene USDT | El pago a ese destinatario falló | Marca como completadas solo las transferencias verificadas. Concilia los destinatarios fallidos y cualquier reembolso antes de un lote nuevo. |
| "The batch or the fee changed" | El formulario, la comisión o la configuración del socio cambiaron después de la vista previa | Vuelve a mostrar la vista previa y pide al remitente que revise los nuevos totales. |
| "The payout contract is paused" | Los pagos están detenidos temporalmente en el contrato | No envíes. Inténtalo más tarde. |
| TronGrid devuelve errores o respuestas de límite de solicitudes | Los endpoints públicos sin clave de API limitan la frecuencia de solicitudes | Usa una clave de API de TronGrid o tu propio nodo, y vuelve a intentarlo. |
Relacionado
- Enviar pagos cripto no custodiales — cómo funcionan los pagos no custodiales
- Integra pagos en USDT BEP-20 en BNB Smart Chain — el mismo formulario de pagos en BNB Smart Chain con MetaMask
- Integra pagos en USDT ERC-20 en Ethereum — el mismo formulario de pagos en Ethereum con MetaMask
- Enviar pagos desde tu propia billetera — cómo los proyectos hacen pagos por lotes desde una billetera que controlan
- Documentación de TronLink para DApps — cómo conectar TronLink a tu sitio