Intégrer des paiements en USDT ERC-20 sur Ethereum
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 ERC-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 Ethereum Mainnet. Pour les autres réseaux, consultez TRON et BNB Smart Chain.
Avant de commencer
- Portefeuille de l’expéditeur — MetaMask ou un autre portefeuille de navigateur compatible EIP-1193. Les exemples utilisent MetaMask dans Google Chrome.
- Fonds dans le portefeuille de l’expéditeur — des USDT ERC-20 pour les paiements et les frais de traitement, plus des ETH pour les frais de 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 — ethers.js v6. Aucun SDK Volet.com n’est nécessaire.
- Site web — servi en HTTPS, ou depuis
localhostpendant le développement. - Backend et base de données — pour enregistrer chaque lot et vérifier les paiements.
- Fournisseur RPC — un nœud Ethereum Mainnet ou un service hébergé pour la vérification côté backend.
Fonctionnement
- 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.
- L’expéditeur connecte son portefeuille. Votre site n’a jamais besoin de sa clé privée.
- Votre frontend valide le lot et lit les frais de traitement dans le contrat avec
previewCommission(). - Votre site affiche le total des paiements, les frais de traitement, le total d’USDT nécessaire et une estimation des frais de réseau.
- 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, le portefeuille demande d’abord à l’expéditeur de signer une transaction
approve(). - Votre frontend vérifie à nouveau les frais, le portefeuille, le réseau et les destinataires, puis le portefeuille demande à l’expéditeur de signer
batchPayout(). - 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éseau | Ethereum Mainnet, chain ID 1 (0x1) |
| Contrat de paiements | 0x765A0cd00e07C23d1f760BDc794940967Bc6ccC7 (Etherscan) |
| Contrat USDT | 0xdAC17F958D2ee523a2206206994597C13D831ec7 |
| Décimales de l’USDT | 6 (1 USDT = 1 000 000 unités de base) |
| Frais de réseau payés en | ETH |
| Adresse zéro (sans partenaire) | 0x0000000000000000000000000000000000000000 |
La même adresse de contrat de paiements existe aussi sur BNB Smart Chain. Ce sont deux déploiements distincts, non interchangeables : avant de demander une signature, vérifiez toujours le chain ID du portefeuille 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.
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 Etherscan, 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 décimales du token, 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 frais de réseau Ethereum en ETH pour chaque transaction : le paiement et, si elle est nécessaire, l’approbation.
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.
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
Installez ethers.js :
npm install ethers@^6
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 address">
<input name="amount" type="text" placeholder="USDT amount">
</div>
<button id="connect" type="button">Connect wallet</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 ethereum-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.
import { ethers } from 'ethers';
const CHAIN_ID = 1n;
const PAYOUT_ADDRESS = '0x765A0cd00e07C23d1f760BDc794940967Bc6ccC7';
const USDT_ADDRESS = '0xdAC17F958D2ee523a2206206994597C13D831ec7';
export const USDT_DECIMALS = 6;
const EXPLORER_TX = 'https://etherscan.io/tx/';
export const PAYOUT_ABI = [
'function usdt() view returns (address)',
'function MAX_BATCH_SIZE() view returns (uint256)',
'function paused() view returns (bool)',
'function previewCommission(uint256 total, uint256 count) view returns (uint256)',
'function previewCommissionSplit(uint256 total, uint256 count, address whiteLabel) view returns (uint256 platformCommission, uint256 partnerShare)',
'function getPartner(address partner) view returns (bool active, uint16 shareBps)',
'function batchPayout(address[] recipients, uint256[] amounts, address whiteLabel)',
'event BatchPayout(address indexed sender, uint256 total, uint256 commission, uint256 partnerShare, uint256 count, address indexed whiteLabel)',
'event PayoutFailed(address[] recipients, uint256[] amounts)',
'event RefundSent(address indexed sender, uint256 amount)',
'event PartnerNotFound(address indexed whiteLabel)',
'event CommissionTransferFailed(address indexed wallet, uint256 amount)'
];
const TOKEN_ABI = [
'function decimals() view returns (uint8)',
'function balanceOf(address owner) view returns (uint256)',
'function allowance(address owner, address spender) view returns (uint256)',
'function approve(address spender, uint256 amount) returns (bool)'
];
export async function connect() {
if (!window.ethereum) throw new Error('Install and unlock MetaMask.');
await window.ethereum.request({ method: 'eth_requestAccounts' });
const provider = new ethers.BrowserProvider(window.ethereum);
if ((await provider.getNetwork()).chainId !== CHAIN_ID) {
throw new Error('Select Ethereum Mainnet in your wallet, then connect again.');
}
const signer = await provider.getSigner();
const sender = await signer.getAddress();
const payout = new ethers.Contract(PAYOUT_ADDRESS, PAYOUT_ABI, signer);
// Make sure this deployment pays out the expected token.
const tokenAddress = await payout.usdt();
if (tokenAddress.toLowerCase() !== USDT_ADDRESS.toLowerCase()) {
throw new Error('Unexpected USDT token in the payout contract.');
}
const token = new ethers.Contract(tokenAddress, TOKEN_ABI, signer);
if (Number(await token.decimals()) !== USDT_DECIMALS) {
throw new Error('Unexpected token decimals.');
}
return { sender, payout, token };
}
// Signatures go only to the wallet and network the batch was reviewed with.
async function assertWalletUnchanged(session) {
const [chainId, accounts] = await Promise.all([
window.ethereum.request({ method: 'eth_chainId' }),
window.ethereum.request({ method: 'eth_accounts' })
]);
if (BigInt(chainId) !== CHAIN_ID ||
accounts[0]?.toLowerCase() !== session.sender.toLowerCase()) {
throw new Error('Wallet or network changed. Connect again and review the batch.');
}
}
Appelez connect() uniquement lorsque l’expéditeur sélectionne Connect wallet, jamais au chargement de la page. Si le portefeuille est sur un autre réseau, demandez à l’expéditeur de passer sur Ethereum Mainnet.
Étape 3 : Prévisualisez le lot et les frais
Ajoutez les fonctions de validation et de prévisualisation à ethereum-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 parseRows(rows) {
if (!Array.isArray(rows) || rows.length === 0) {
throw new Error('Add at least one recipient.');
}
const recipients = rows.map((row) => {
if (!ethers.isAddress(row.address)) throw new Error(`Invalid recipient address: ${row.address}`);
const address = ethers.getAddress(row.address);
if (address === ethers.ZeroAddress) throw new Error('The zero address cannot receive a payout.');
return address;
});
const amounts = rows.map((row) => {
if (typeof row.amount !== 'string' || !/^\d+(\.\d{1,6})?$/.test(row.amount)) {
throw new Error(`Invalid USDT amount: ${row.amount}`);
}
const amount = ethers.parseUnits(row.amount, USDT_DECIMALS);
if (amount <= 0n) throw new Error('Each amount must be positive.');
return amount;
});
return { recipients, amounts };
}
export async function quote(session, rows, partnerWallet = null) {
const { payout, token, sender } = session;
const { recipients, amounts } = parseRows(rows);
if (await payout.paused()) throw new Error('The payout contract is paused.');
if (BigInt(recipients.length) > await payout.MAX_BATCH_SIZE()) {
throw new Error('The batch has more recipients than the contract allows.');
}
if (partnerWallet && !ethers.isAddress(partnerWallet)) {
throw new Error('Invalid partner address.');
}
const whiteLabel = partnerWallet ? ethers.getAddress(partnerWallet) : ethers.ZeroAddress;
const total = amounts.reduce((sum, amount) => sum + amount, 0n);
const commission = await payout.previewCommission(total, recipients.length);
const [platformCommission, partnerShare] = await payout.previewCommissionSplit(
total, recipients.length, whiteLabel
);
return {
recipients, amounts, whiteLabel, total, commission,
platformCommission, partnerShare,
required: total + commission,
balance: await token.balanceOf(sender),
allowance: await token.allowance(sender, PAYOUT_ADDRESS)
};
}
Affichez à l’expéditeur total, commission et required, mis en forme avec ethers.formatUnits(value, USDT_DECIMALS), ainsi qu’une estimation des frais de réseau en ETH. Ne convertissez pas les montants en virgule flottante : parseUnits() les garde exacts.
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 Ethereum capables de recevoir des USDT ERC-20.
Étape 4 : Approuvez les USDT et envoyez le lot
Ajoutez la fonction d’envoi à ethereum-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, 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 confirmed(tx, message) {
const receipt = await tx.wait();
if (!receipt || receipt.status !== 1) throw new Error(message);
}
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) {
// Ethereum USDT rejects changing a non-zero allowance to another non-zero value.
if (current.allowance > 0n) {
await confirmed(await token.approve(PAYOUT_ADDRESS, 0n), 'Allowance reset failed.');
}
await confirmed(await token.approve(PAYOUT_ADDRESS, current.required), 'USDT approval failed.');
}
// 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 tx = await payout.batchPayout(fresh.recipients, fresh.amounts, fresh.whiteLabel);
return { txid: tx.hash, explorerUrl: EXPLORER_TX + tx.hash };
}
Selon l’autorisation de dépense existante, l’expéditeur signe une à trois transactions :
| Autorisation existante | Transactions à signer |
|---|---|
| Suffisante pour le lot | Paiement |
| Nulle | Approbation, paiement |
| Non nulle mais insuffisante | Remise à zéro de l’autorisation, approbation, paiement |
L’approbation couvre exactement le montant de ce lot, jamais un montant illimité. Chaque approbation doit être confirmée avant la transaction suivante ; une transaction approve() ne déplace aucun fonds.
É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 { ethers } from 'ethers';
import { USDT_DECIMALS, connect, quote, send } from './ethereum-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 usdt(units) {
return `${ethers.formatUnits(units, USDT_DECIMALS)} USDT`;
}
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.ethereum?.on?.('accountsChanged', resetSession);
window.ethereum?.on?.('chainChanged', resetSession);
async function onConnect() {
session = await connect();
reviewed = null;
show(`Connected: ${session.sender}`);
}
async function onPreview() {
if (!session) throw new Error('Connect a wallet first.');
reviewed = await quote(session, readRows(), readPartner());
show([
`Payouts: ${usdt(reviewed.total)}`,
`Processing fee: ${usdt(reviewed.commission)}`,
`Total required: ${usdt(reviewed.required)}`
].join(' | '));
}
async function onSend() {
if (!session || !reviewed) throw new Error('Connect a wallet and preview the batch first.');
if (!window.confirm('Send this batch? Your wallet 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.shortMessage ?? 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 et le chain ID
- 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
- 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 vérifie chaque destinataire à partir des logs Transfer d’USDT de la transaction. L’exemple ci-dessous s’exécute dans Node.js avec ethers v6. Il prend le lot dans votre base de données, et non dans le navigateur.
import { ethers } from 'ethers';
import { PAYOUT_ABI } from './ethereum-payouts.js';
const provider = new ethers.JsonRpcProvider(process.env.ETHEREUM_RPC_URL);
const PAYOUT_ADDRESS = '0x765A0cd00e07C23d1f760BDc794940967Bc6ccC7';
const USDT_ADDRESS = '0xdAC17F958D2ee523a2206206994597C13D831ec7';
const tokenEvents = new ethers.Interface([
'event Transfer(address indexed from, address indexed to, uint256 value)'
]);
const payoutEvents = new ethers.Interface(PAYOUT_ABI);
export async function verifyPayout(batch) {
const receipt = await provider.getTransactionReceipt(batch.txid);
if (!receipt) return { status: 'pending' };
if (receipt.status !== 1) return { status: 'failed' };
if (receipt.to?.toLowerCase() !== PAYOUT_ADDRESS.toLowerCase() ||
receipt.from.toLowerCase() !== batch.sender.toLowerCase()) {
return { status: 'review', reason: 'Unexpected sender or contract.' };
}
const finalized = await provider.getBlock('finalized');
if (!finalized || receipt.blockNumber > finalized.number) return { status: 'pending' };
const received = new Map();
const failed = [];
let refunded = 0n;
for (const log of receipt.logs) {
const source = log.address.toLowerCase();
if (source === USDT_ADDRESS.toLowerCase()) {
const event = tokenEvents.parseLog(log);
if (event?.name !== 'Transfer') continue;
const to = event.args.to.toLowerCase();
received.set(to, (received.get(to) ?? 0n) + event.args.value);
} else if (source === PAYOUT_ADDRESS.toLowerCase()) {
const event = payoutEvents.parseLog(log);
if (event?.name === 'PayoutFailed') failed.push(...event.args.recipients);
if (event?.name === 'RefundSent') refunded += event.args.amount;
}
}
const expected = new Map();
batch.recipients.forEach((address, i) => {
const key = address.toLowerCase();
expected.set(key, (expected.get(key) ?? 0n) + BigInt(batch.amounts[i]));
});
const results = [...expected].map(([address, amount]) => ({
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,
failed,
refunded: refunded.toString()
};
}
Ne marquez comme terminés que les destinataires avec paid: true. Pour les autres, rapprochez les événements PayoutFailed et RefundSent et vérifiez le solde de l’expéditeur avant de les payer dans un nouveau lot. Ne renvoyez jamais automatiquement un lot entier.
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é, vérifie les événements liés au partenaire et aux frais, et gère un fournisseur RPC indisponible ou qui ne renvoie pas de données de finalité : laissez le lot en attente et réessayez.
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 le portefeuille de l’expéditeur.
- 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 frais de réseau.
- Le portefeuille 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ème | Cause | Que faire |
|---|---|---|
| « Install and unlock MetaMask » | Aucun portefeuille EIP-1193 dans le navigateur, ou il est verrouillé | Demandez à l’expéditeur d’installer ou de déverrouiller le portefeuille. |
| « Select Ethereum Mainnet in your wallet » | Le portefeuille est sur un autre réseau | Demandez à l’expéditeur de passer sur Ethereum Mainnet et de se reconnecter. Ne demandez aucune signature sur un autre réseau. |
| L’expéditeur refuse la connexion, l’approbation ou le paiement | L’expéditeur a annulé la demande dans le portefeuille | Ne soumettez pas le lot et affichez un message clair. |
| « Invalid recipient address » ou « Invalid USDT amount » | Une ligne du formulaire contient une erreur | Bloquez 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 frais | Affichez le total nécessaire et les ETH nécessaires pour les frais de réseau. |
| L’approbation est toujours en attente | La transaction d’approbation n’est pas encore confirmée | Attendez la confirmation. Ne considérez jamais une approbation comme acquise sur la seule base de son hash de transaction. |
| La transaction de paiement est toujours en attente | La transaction n’est pas encore dans un bloc finalisé | Suivez le txid d’origine. Ne diffusez pas à nouveau le même lot. |
| La transaction a réussi, mais un destinataire n’a pas reçu d’USDT | Le 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évisualisation | Relancez 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 contrat | N’envoyez rien. Réessayez plus tard. |
Voir aussi
- Envoyer des paiements crypto non dépositaires — comment fonctionnent les paiements non dépositaires
- Intégrer des paiements en USDT BEP-20 sur BNB Smart Chain — le même formulaire de paiements sur BNB Smart Chain
- Intégrer des paiements en USDT TRC-20 sur TRON — le même formulaire de paiements sur TRON avec TronLink
- Payer depuis votre propre portefeuille — comment des projets effectuent des paiements par lots depuis un portefeuille qu’ils contrôlent
- Documentation ethers.js v6 — la bibliothèque utilisée dans les exemples