Aller au contenu principal

Intégrer des paiements en USDT TRC-20 sur TRON

Ajoutez à votre site un formulaire de paiements de masse : l’expéditeur connecte son propre portefeuille, saisit les destinataires et les montants en USDT, vérifie les frais et signe le lot. Le contrat de paiements de Volet.com envoie les USDT TRC-20 du portefeuille de l’expéditeur directement vers les portefeuilles des destinataires : les fonds ne transitent jamais par un compte Volet.com.

Ce guide couvre TRON Mainnet. Pour les autres réseaux, consultez BNB Smart Chain et Ethereum.

Avant de commencer​

  • Portefeuille de l’expéditeur — TronLink. Les exemples utilisent l’extension TronLink dans Google Chrome, qui fournit TronWeb à votre page une fois l’expéditeur connecté.
  • Fonds dans le portefeuille de l’expéditeur — des USDT TRC-20 pour les paiements et les frais de traitement, plus des TRX ou de l’Energy et de la Bandwidth en staking pour les coûts du réseau. Vous n’avez pas besoin d’alimenter un portefeuille pour créer le formulaire : c’est l’expéditeur qui paie lorsqu’il envoie un lot.
  • Bibliothèque — rien à installer pour la partie navigateur : TronLink injecte TronWeb. L’exemple backend utilise le paquet npm tronweb. Aucun SDK Volet.com n’est nécessaire.
  • Site web — servi en HTTPS, ou depuis localhost pendant le développement.
  • Backend et base de données — pour enregistrer chaque lot et vérifier les paiements.
  • Accès à la blockchain — un nœud TRON ou un service hébergé, comme TronGrid. Les endpoints publics de TronGrid peuvent exiger une clé d’API et limitent la fréquence des requêtes.

Fonctionnement​

  1. L’expéditeur remplit le formulaire de paiements sur votre site : adresses des destinataires, montants en USDT et, en option, l’adresse d’un partenaire.
  2. L’expéditeur connecte TronLink. Votre site n’a jamais besoin de sa clé privée.
  3. Votre frontend valide le lot et lit les frais de traitement dans le contrat avec previewCommission().
  4. Votre site affiche le total des paiements, les frais de traitement, le total d’USDT nécessaire et une estimation des coûts du réseau.
  5. Lorsque l’expéditeur confirme, votre frontend vérifie le solde en USDT et l’autorisation de dépense (allowance). Si l’autorisation est insuffisante, TronLink demande d’abord à l’expéditeur de signer une transaction approve().
  6. Votre frontend vérifie à nouveau les frais, le portefeuille, le réseau et les destinataires, puis TronLink demande à l’expéditeur de signer batchPayout().
  7. Votre backend enregistre le hash de transaction (txid) et vérifie le transfert d’USDT à chaque destinataire avant de marquer ce paiement comme terminé.

L’échec d’un paiement à un destinataire n’annule pas forcément les autres : une transaction réussie ne prouve donc pas que tout le monde a été payé. Consultez Étape 7 : Vérifiez chaque paiement.

Contrat de paiements​

Valeur
RéseauTRON Mainnet, chain ID 0x2b6653dc dans TronLink
Contrat de paiementsTHwUFuithr9QuTFa4wBjN2zxFWjUrftV84 (TRONSCAN)
Contrat USDTTR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t
Décimales de l’USDT6 (1 USDT = 1 000 000 unités de base)
Coûts du réseau payés enTRX, ou Energy et Bandwidth en staking
Adresse zéro (sans partenaire)T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb

Avant de demander une signature, vérifiez toujours le réseau actif et le résultat de usdt() du contrat.

Le contrat propose ces fonctions :

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;

Il émet les événements BatchPayout, PayoutFailed, RefundSent, PartnerNotFound et CommissionTransferFailed. PayoutFailed liste les destinataires et les montants qui n’ont pas été payés.

Vérifiez l’ABI du contrat

Les exemples de cette page ne contiennent que les fonctions et les événements qu’ils utilisent. Avant l’intégration, ouvrez le contrat de paiements sur TRONSCAN, récupérez son ABI complet dans l’onglet Contract et comparez-y les signatures des fonctions, les types de paramètres et les événements de votre code. Avant d’envoyer des fonds réels, comparez aussi avec cette page l’adresse du token renvoyée par usdt(), les résultats de previewCommission() et les événements du contrat.

Frais​

Les frais de traitement sont de 0.1 USDT par destinataire du lot, en plus des montants des paiements. Par exemple, un lot qui verse 10, 20 et 30 USDT à 3 destinataires nécessite 60 USDT pour les paiements et 0.3 USDT pour les frais : 60.3 USDT au total.

Affichez toujours à l’expéditeur la valeur actuelle de previewCommission(), et non des frais calculés dans votre code.

L’expéditeur paie aussi les coûts du réseau TRON (Energy et Bandwidth) de chaque transaction : le paiement et, si elle est nécessaire, l’approbation. Ils sont couverts par des ressources en staking ou par des TRX brûlés.

Adresse du partenaire​

batchPayout() prend un argument whiteLabel pour le portefeuille facultatif d’un partenaire qui partage les frais de traitement. Un lot fonctionne sans partenaire : transmettez l’adresse zéro de TRON.

Avec un partenaire, transmettez l’adresse de son portefeuille. getPartner() indique si l’adresse est un partenaire actif et sa part en points de base, et previewCommissionSplit() montre comment les frais sont répartis entre Volet.com et le partenaire. Les frais payés par l’expéditeur ne changent pas : previewCommission() ne dépend pas du partenaire.

Pour enregistrer le portefeuille d’un partenaire, écrivez à [email protected] en indiquant l’adresse du portefeuille et le réseau.

Étape 1 : Ajoutez le formulaire de paiements​

Ajoutez les champs du formulaire à votre page. Chaque bloc data-payout-row correspond à un destinataire ; ajoutez ou supprimez des blocs pour changer le nombre de destinataires.

<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>

Avant de mettre le formulaire en production, ajoutez vos propres styles, la gestion des lignes, des indicateurs de progression et la désactivation des boutons.

Étape 2 : Connectez le portefeuille de l’expéditeur​

Créez tron-payouts.js, un module côté navigateur, et commencez-le par la configuration du contrat et la fonction de connexion. Les étapes 3 et 4 complètent le même fichier.

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

Appelez connect() uniquement lorsque l’expéditeur sélectionne Connect TronLink, jamais au chargement de la page.

Étape 3 : Prévisualisez le lot et les frais​

Ajoutez les fonctions de validation et de prévisualisation à tron-payouts.js. quote() convertit les lignes du formulaire en arguments du contrat en unités de base d’USDT et lit les frais, le solde et l’autorisation de dépense.

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

Affichez à l’expéditeur total, commission et required, mis en forme avec formatUsdt(), ainsi qu’une estimation des coûts du réseau. Ne convertissez pas les montants en virgule flottante : les unités de base les gardent exacts.

Vérifiez les destinataires avant de signer

Un paiement envoyé à une mauvaise adresse ne peut être ni annulé ni restitué. Montrez à l’expéditeur chaque adresse et chaque montant avant la signature, et n’acceptez que des adresses TRON capables de recevoir des USDT TRC-20.

Étape 4 : Approuvez les USDT et envoyez le lot​

Ajoutez la fonction d’envoi à tron-payouts.js. Elle vérifie que rien n’a changé depuis que l’expéditeur a vérifié le lot, demande une approbation si l’autorisation de dépense est insuffisante, attend que l’approbation soit solidifiée, puis soumet 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}` };
}

Selon l’autorisation de dépense existante, l’expéditeur signe une à trois transactions :

Autorisation existanteTransactions à signer
Suffisante pour le lotPaiement
NulleApprobation, paiement
Non nulle mais insuffisanteRemise à zéro de l’autorisation, approbation, paiement

L’approbation couvre exactement le montant de ce lot, jamais un montant illimité. Chaque approbation doit être solidifiée avant la transaction suivante, ce qui prend généralement environ une minute ; une transaction approve() ne déplace aucun fonds.

FEE_LIMIT_SUN est le maximum qu’une transaction peut dépenser en coûts du réseau (300 TRX), pas son coût réel. Estimez l’Energy nécessaire à un lot et fixez un plafond adapté.

Étape 5 : Branchez les boutons​

Reliez le module au formulaire. Les requêtes vers le portefeuille ne partent que des clics de l’expéditeur, et les destinataires et les montants viennent toujours du formulaire.

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 l’expéditeur modifie le formulaire après la prévisualisation, send() s’arrête avec « The batch or the fee changed » et l’expéditeur relance la prévisualisation.

Étape 6 : Enregistrez le lot​

Enregistrez chaque lot dans votre backend avant que l’expéditeur ne le signe, et ne l’écrasez jamais. Conservez :

  • votre propre identifiant de lot
  • le réseau
  • l’adresse de l’expéditeur
  • la liste des destinataires et les montants exacts en unités de base d’USDT
  • l’adresse du partenaire ou l’adresse zéro de TRON
  • les frais de traitement annoncés
  • les hashes des transactions d’approbation, le cas échéant
  • le hash de la transaction de paiement (txid)
  • le statut final de chaque destinataire

batchPayout() n’accepte pas d’identifiant de lot : le lien entre votre lot et sa transaction n’existe que dans votre base de données. Servez-vous-en pour éviter les doublons : si une transaction est toujours en attente, suivez son txid et ne renvoyez pas le même lot.

Étape 7 : Vérifiez chaque paiement​

Un hash de transaction indique seulement que le lot a été soumis. Un reçu réussi ou un événement BatchPayout ne prouve pas non plus que chaque destinataire a été payé : l’échec d’un paiement à un destinataire n’annule pas forcément les autres, et le contrat le signale par PayoutFailed et peut rembourser l’expéditeur par RefundSent.

Votre backend lit les données solidifiées de la transaction depuis un SolidityNode :

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

Les deux reçoivent le hash de la transaction dans le corps : {"value": "<txid>"}.

Il vérifie ensuite chaque destinataire à partir des événements Transfer d’USDT de la transaction. L’exemple ci-dessous s’exécute dans Node.js avec le paquet tronweb. Il prend le lot dans votre base de données, et non dans le navigateur.

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

Ne marquez comme terminés que les destinataires avec paid: true. Pour les autres, recherchez les événements PayoutFailed et RefundSent de la transaction, par exemple sur TRONSCAN, et vérifiez le solde de l’expéditeur avant de les payer dans un nouveau lot. Ne renvoyez jamais automatiquement un lot entier.

Une transaction qui n’est pas encore solidifiée est en attente, pas en échec : laissez le lot en attente et réessayez. Cette vérification couvre les transferts aux destinataires. En production, votre backend compare aussi les données d’entrée de la transaction avec le lot enregistré et vérifie les événements liés au partenaire et aux frais. Pour comprendre la solidification, consultez TRON confirmation semantics.

Points importants​

  • Ne demandez jamais aux expéditeurs leurs clés privées ni leurs phrases de récupération. Toutes les signatures se font dans TronLink.
  • Ne demandez jamais par défaut une approbation illimitée d’USDT.
  • Avant chaque signature, affichez l’adresse du contrat de paiements, les destinataires, les frais de traitement et l’estimation des coûts du réseau.
  • TronLink est la dernière étape d’approbation. La vérification du résultat incombe à votre application.
  • Les transactions confirmées sur la blockchain ne peuvent être ni annulées ni inversées.

En cas de problème​

ProblèmeCauseQue faire
« Install and unlock TronLink »TronLink n’est pas installé dans le navigateur, ou il est verrouilléDemandez à l’expéditeur d’installer ou de déverrouiller TronLink.
TronLink demande de changer de réseauLe portefeuille n’est pas sur TRON MainnetDemandez à l’expéditeur de confirmer le changement. Ne demandez aucune signature sur un autre réseau.
L’expéditeur refuse la connexion, l’approbation ou le paiementL’expéditeur a annulé la demande dans TronLinkNe soumettez pas le lot et affichez un message clair.
« Invalid recipient address » ou « Invalid USDT amount »Une ligne du formulaire contient une erreurBloquez la prévisualisation et l’envoi jusqu’à ce que l’expéditeur corrige ce destinataire.
« Not enough USDT in the sender wallet »Le solde est inférieur aux paiements plus les fraisAffichez le total nécessaire et les TRX nécessaires pour les coûts du réseau.
Une transaction échoue faute d’Energy (out of energy)L’expéditeur a trop peu de TRX ou d’Energy, ou la limite de frais est trop basse pour le lotDemandez à l’expéditeur d’ajouter des TRX ou de staker pour obtenir de l’Energy, ou augmentez la limite de frais pour les gros lots.
« Transaction is still pending »L’approbation ou le paiement n’est pas encore solidifiéSuivez le txid d’origine. Ne diffusez pas à nouveau la même transaction.
La transaction a réussi, mais un destinataire n’a pas reçu d’USDTLe paiement à ce destinataire a échouéNe marquez comme terminés que les transferts vérifiés. Rapprochez les destinataires en échec et tout remboursement avant un nouveau lot.
« The batch or the fee changed »Le formulaire, les frais ou les paramètres du partenaire ont changé après la prévisualisationRelancez la prévisualisation et demandez à l’expéditeur de vérifier les nouveaux totaux.
« The payout contract is paused »Les paiements sont temporairement suspendus dans le contratN’envoyez rien. Réessayez plus tard.
TronGrid renvoie des erreurs ou des réponses de limite de requêtesLes endpoints publics sans clé d’API limitent la fréquence des requêtesUtilisez une clé d’API TronGrid ou votre propre nœud, puis réessayez.