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
localhostdurante 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
- 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.
- O remetente conecta o TronLink. Seu site nunca precisa da chave privada dele.
- Seu frontend valida o lote e obtém a taxa de processamento do contrato com
previewCommission(). - Seu site mostra o total dos pagamentos, a taxa de processamento, o total de USDT necessário e uma estimativa dos custos de rede.
- 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(). - 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(). - 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 | |
|---|---|
| Rede | TRON Mainnet, chain ID 0x2b6653dc no TronLink |
| Contrato de pagamentos | THwUFuithr9QuTFa4wBjN2zxFWjUrftV84 (TRONSCAN) |
| Contrato do USDT | TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t |
| Casas decimais do USDT | 6 (1 USDT = 1.000.000 unidades base) |
| Custos de rede pagos em | TRX, 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.
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.
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 existente | Transações a assinar |
|---|---|
| Suficiente para o lote | Pagamento |
| Zero | Aprovação, pagamento |
| Diferente de zero, mas insuficiente | Redefiniçã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
| Problema | Causa | O que fazer |
|---|---|---|
| "Install and unlock TronLink" | O TronLink não está instalado no navegador ou está bloqueado | Peça ao remetente que instale ou desbloqueie o TronLink. |
| O TronLink pede para trocar de rede | A carteira não está na TRON Mainnet | Peç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 pagamento | O remetente cancelou a solicitação no TronLink | Não envie o lote e mostre uma mensagem clara. |
| "Invalid recipient address" ou "Invalid USDT amount" | Uma linha do formulário tem um erro | Bloqueie 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 taxa | Mostre 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 lote | Peç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 solidificados | Acompanhe 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 USDT | O pagamento a esse destinatário falhou | Marque 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ção | Faç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 contrato | Não envie. Tente de novo mais tarde. |
| O TronGrid retorna erros ou respostas de limite de requisições | Endpoints públicos sem chave de API limitam a frequência de requisições | Use uma chave de API do TronGrid ou seu próprio nó e tente de novo. |
Relacionados
- Enviar pagamentos cripto não custodiais — como funcionam os pagamentos não custodiais
- Integre pagamentos em USDT BEP-20 na BNB Smart Chain — o mesmo formulário de pagamentos na BNB Smart Chain com MetaMask
- Integre pagamentos em USDT ERC-20 na Ethereum — o mesmo formulário de pagamentos na Ethereum com MetaMask
- Enviar pagamentos da sua própria carteira — como projetos fazem pagamentos em lote a partir de uma carteira que controlam
- Documentação do TronLink para DApps — como conectar o TronLink ao seu site