Pular para o conteúdo principal

Integre pagamentos em USDT TRC-20 na TRON

Adicione ao seu site um formulário de pagamentos em massa: o remetente conecta a própria carteira, informa os destinatários e os valores em USDT, confere a taxa e assina o lote. O contrato de pagamentos da Volet.com envia USDT TRC-20 da carteira do remetente diretamente para as carteiras dos destinatários, então os fundos nunca passam por uma conta da Volet.com.

Este guia cobre a TRON Mainnet. Para outras redes, consulte BNB Smart Chain e Ethereum.

Antes de começar​

  • Carteira do remetente — TronLink. Os exemplos usam a extensão TronLink no Google Chrome, que fornece o TronWeb à sua página quando o remetente se conecta.
  • Fundos na carteira do remetente — USDT TRC-20 para os pagamentos e a taxa de processamento, além de TRX ou Energy e Bandwidth em staking para os custos de rede. Você não precisa abastecer nenhuma carteira para criar o formulário: quem paga é o remetente, ao enviar um lote.
  • Biblioteca — a parte do navegador não exige instalação: o TronLink injeta o TronWeb. O exemplo de backend usa o pacote npm tronweb. Nenhum SDK da Volet.com é necessário.
  • Site — servido por HTTPS ou a partir de localhost durante o desenvolvimento.
  • Backend e banco de dados — para guardar cada lote e verificar os pagamentos.
  • Acesso à blockchain — um nó TRON ou um serviço hospedado, como o TronGrid. Os endpoints públicos do TronGrid podem exigir uma chave de API e limitam a frequência de requisições.

Como funciona​

  1. O remetente preenche o formulário de pagamentos no seu site: endereços dos destinatários, valores em USDT e, opcionalmente, o endereço de um parceiro.
  2. O remetente conecta o TronLink. Seu site nunca precisa da chave privada dele.
  3. Seu frontend valida o lote e obtém a taxa de processamento do contrato com previewCommission().
  4. Seu site mostra o total dos pagamentos, a taxa de processamento, o total de USDT necessário e uma estimativa dos custos de rede.
  5. Quando o remetente confirma, seu frontend verifica o saldo de USDT e a permissão de gasto (allowance). Se a permissão não for suficiente, o TronLink pede ao remetente que assine antes uma transação approve().
  6. Seu frontend confere de novo a taxa, a carteira, a rede e os destinatários, e então o TronLink pede ao remetente que assine batchPayout().
  7. Seu backend salva o hash da transação (txid) e verifica a transferência de USDT para cada destinatário antes de marcar esse pagamento como concluído.

Se o pagamento a um destinatário falhar, os outros não são necessariamente cancelados, por isso uma transação bem-sucedida não prova que todos receberam. Consulte Etapa 7: Verifique cada pagamento.

Contrato de pagamentos​

Valor
RedeTRON Mainnet, chain ID 0x2b6653dc no TronLink
Contrato de pagamentosTHwUFuithr9QuTFa4wBjN2zxFWjUrftV84 (TRONSCAN)
Contrato do USDTTR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t
Casas decimais do USDT6 (1 USDT = 1.000.000 unidades base)
Custos de rede pagos emTRX, ou Energy e Bandwidth em staking
Endereço zero (sem parceiro)T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb

Antes de pedir uma assinatura, sempre confira a rede ativa e o resultado de usdt() do contrato.

O contrato oferece estas funções:

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;

Ele emite os eventos BatchPayout, PayoutFailed, RefundSent, PartnerNotFound e CommissionTransferFailed. PayoutFailed lista os destinatários e os valores que não foram pagos.

Confira a ABI do contrato

Os exemplos desta página incluem apenas as funções e os eventos que usam. Antes de integrar, abra o contrato de pagamentos no TRONSCAN, pegue a ABI completa na aba Contract e compare com ela as assinaturas das funções, os tipos de parâmetros e os eventos do seu código. Antes de enviar fundos reais, compare também com esta página o endereço do token retornado por usdt(), os resultados de previewCommission() e os eventos do contrato.

Taxas​

A taxa de processamento é de 0.1 USDT por destinatário do lote, somada aos valores dos pagamentos. Por exemplo, um lote que paga 10, 20 e 30 USDT a 3 destinatários precisa de 60 USDT para os pagamentos e 0.3 USDT para a taxa: 60.3 USDT no total.

Sempre mostre ao remetente o valor atual de previewCommission(), e não uma taxa calculada no seu código.

O remetente também paga os custos de rede da TRON (Energy e Bandwidth) de cada transação: o pagamento e, quando necessária, a aprovação. Eles são cobertos por recursos em staking ou por TRX queimados.

Endereço do parceiro​

batchPayout() recebe o argumento whiteLabel para a carteira opcional de um parceiro que divide a taxa de processamento. Um lote funciona sem parceiro: passe o endereço zero da TRON.

Se houver parceiro, passe o endereço da carteira dele. getPartner() mostra se o endereço é de um parceiro ativo e qual é a participação dele em pontos-base, e previewCommissionSplit() mostra como a taxa é dividida entre a Volet.com e o parceiro. A taxa paga pelo remetente não muda: previewCommission() não depende do parceiro.

Para registrar a carteira de um parceiro, escreva para [email protected] informando o endereço da carteira e a rede.

Etapa 1: Adicione o formulário de pagamentos​

Adicione os controles do formulário à sua página. Cada bloco data-payout-row é um destinatário; adicione ou remova blocos para mudar o número de destinatários.

<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 colocar o formulário em produção, adicione seus próprios estilos, o gerenciamento de linhas, os indicadores de progresso e o estado desabilitado dos botões.

Etapa 2: Conecte a carteira do remetente​

Crie tron-payouts.js, um módulo do navegador, e comece-o com a configuração do contrato e a função de conexão. As etapas 3 e 4 acrescentam código ao mesmo arquivo.

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.');
}
}

Chame connect() apenas quando o remetente selecionar Connect TronLink, nunca no carregamento da página.

Etapa 3: Mostre o lote e a taxa​

Adicione as funções de validação e de pré-visualização a tron-payouts.js. quote() transforma as linhas do formulário em argumentos do contrato em unidades base de USDT e obtém a taxa, o saldo e a permissão 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())
};
}

Mostre ao remetente total, commission e required, formatados com formatUsdt(), junto com uma estimativa dos custos de rede. Não converta valores com aritmética de ponto flutuante: as unidades base os mantêm exatos.

Confira os destinatários antes de assinar

Um pagamento enviado a um endereço errado não pode ser cancelado nem devolvido. Mostre ao remetente cada endereço e cada valor antes da assinatura e aceite apenas endereços TRON que possam receber USDT TRC-20.

Etapa 4: Aprove o USDT e envie o lote​

Adicione a função de envio a tron-payouts.js. Ela verifica se nada mudou desde que o remetente revisou o lote, pede uma aprovação se a permissão de gasto não for suficiente, espera a aprovação ficar solidificada e então envia 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}` };
}

Dependendo da permissão de gasto existente, o remetente assina de uma a três transações:

Permissão existenteTransações a assinar
Suficiente para o lotePagamento
ZeroAprovação, pagamento
Diferente de zero, mas insuficienteRedefinição da permissão para zero, aprovação, pagamento

A aprovação cobre exatamente o valor deste lote, nunca um valor ilimitado. Cada aprovação precisa ficar solidificada antes da próxima transação, o que costuma levar cerca de um minuto; uma transação approve() não movimenta fundos.

FEE_LIMIT_SUN é o máximo que uma transação pode gastar em custos de rede (300 TRX), e não o custo dela. Estime a Energy de que um lote precisa e defina um teto adequado.

Etapa 5: Conecte os botões​

Ligue o módulo ao formulário. As solicitações à carteira partem apenas dos cliques do remetente, e os destinatários e os valores sempre vêm do formulário.

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)));
});
}

Se o remetente editar o formulário depois da pré-visualização, send() para com "The batch or the fee changed", e o remetente faz a pré-visualização de novo.

Etapa 6: Registre o lote​

Guarde cada lote no seu backend antes que o remetente o assine e nunca o sobrescreva. Mantenha:

  • seu próprio ID do lote
  • a rede
  • o endereço do remetente
  • a lista de destinatários e os valores exatos em unidades base de USDT
  • o endereço do parceiro ou o endereço zero da TRON
  • a taxa de processamento cotada
  • os hashes das transações de aprovação, se houver
  • o hash da transação de pagamento (txid)
  • o status final de cada destinatário

batchPayout() não aceita um ID de lote, então o vínculo entre o seu lote e a transação dele existe apenas no seu banco de dados. Use-o para evitar duplicidades: se uma transação ainda estiver pendente, acompanhe o txid dela e não envie o mesmo lote de novo.

Etapa 7: Verifique cada pagamento​

Um hash de transação mostra apenas que o lote foi enviado. Um recibo bem-sucedido ou um evento BatchPayout também não provam que todos os destinatários receberam: se o pagamento a um deles falhar, os outros não são necessariamente cancelados, e o contrato informa isso com PayoutFailed e pode reembolsar o remetente com RefundSent.

Seu backend lê os dados solidificados da transação a partir de um SolidityNode:

POST https://api.trongrid.io/walletsolidity/gettransactionbyid
POST https://api.trongrid.io/walletsolidity/gettransactioninfobyid

Os dois recebem o hash da transação no corpo: {"value": "<txid>"}.

Em seguida, ele confere cada destinatário com os eventos Transfer de USDT da transação. O exemplo abaixo roda em Node.js com o pacote tronweb. Ele pega o lote do seu banco de dados, e não do 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
};
}

Marque como concluídos apenas os destinatários com paid: true. Para os demais, procure os eventos PayoutFailed e RefundSent da transação, por exemplo no TRONSCAN, e confira o saldo do remetente antes de pagá-los em um novo lote. Nunca reenvie um lote inteiro automaticamente.

Uma transação que ainda não foi solidificada está pendente, e não com falha: mantenha o lote pendente e tente de novo. Essa verificação cobre as transferências aos destinatários. Em produção, seu backend também compara os dados de entrada da transação com o lote salvo e confere os eventos do parceiro e da taxa. Para entender como funciona a solidificação, consulte TRON confirmation semantics.

Observações importantes​

  • Nunca peça aos remetentes chaves privadas ou frases-semente. Todas as assinaturas acontecem no TronLink.
  • Nunca peça por padrão uma aprovação ilimitada de USDT.
  • Antes de cada assinatura, mostre o endereço do contrato de pagamentos, os destinatários, a taxa de processamento e a estimativa dos custos de rede.
  • O TronLink é a última etapa de aprovação. Verificar o resultado é responsabilidade da sua aplicação.
  • Transações confirmadas na blockchain não podem ser canceladas nem revertidas.

Se algo der errado​

ProblemaCausaO que fazer
"Install and unlock TronLink"O TronLink não está instalado no navegador ou está bloqueadoPeça ao remetente que instale ou desbloqueie o TronLink.
O TronLink pede para trocar de redeA carteira não está na TRON MainnetPeça ao remetente que confirme a troca. Não peça nenhuma assinatura em outra rede.
O remetente recusa a conexão, a aprovação ou o pagamentoO remetente cancelou a solicitação no TronLinkNão envie o lote e mostre uma mensagem clara.
"Invalid recipient address" ou "Invalid USDT amount"Uma linha do formulário tem um erroBloqueie a pré-visualização e o envio até o remetente corrigir esse destinatário.
"Not enough USDT in the sender wallet"O saldo é menor que os pagamentos mais a taxaMostre o total necessário e os TRX necessários para os custos de rede.
Uma transação falha por falta de Energy (out of energy)O remetente tem pouco TRX ou pouca Energy, ou o limite de taxa é baixo para o lotePeça ao remetente que adicione TRX ou faça staking para obter Energy, ou aumente o limite de taxa para lotes grandes.
"Transaction is still pending"A aprovação ou o pagamento ainda não foram solidificadosAcompanhe o txid original. Não transmita a mesma transação de novo.
A transação foi bem-sucedida, mas um destinatário não tem USDTO pagamento a esse destinatário falhouMarque como concluídas apenas as transferências verificadas. Concilie os destinatários com falha e qualquer reembolso antes de um novo lote.
"The batch or the fee changed"O formulário, a taxa ou as configurações do parceiro mudaram depois da pré-visualizaçãoFaça a pré-visualização de novo e peça ao remetente que revise os novos totais.
"The payout contract is paused"Os pagamentos estão temporariamente suspensos no contratoNão envie. Tente de novo mais tarde.
O TronGrid retorna erros ou respostas de limite de requisiçõesEndpoints públicos sem chave de API limitam a frequência de requisiçõesUse uma chave de API do TronGrid ou seu próprio nó e tente de novo.