Zum Hauptinhalt springen

USDT-TRC-20-Auszahlungen auf TRON integrieren

Fügen Sie Ihrer Website ein Formular für Massenauszahlungen hinzu: Der Absender verbindet sein eigenes Wallet, gibt Empfänger und USDT-Beträge ein, prüft die Gebühr und signiert den Stapel. Der Auszahlungs-Contract von Volet.com sendet USDT TRC-20 aus dem Wallet des Absenders direkt an die Wallets der Empfänger, sodass die Mittel nie über ein Volet.com-Konto laufen.

Diese Anleitung behandelt TRON Mainnet. Für andere Netzwerke siehe BNB Smart Chain und Ethereum.

Bevor Sie beginnen​

  • Wallet des Absenders — TronLink. Die Beispiele verwenden die TronLink-Erweiterung in Google Chrome, die Ihrer Seite TronWeb bereitstellt, sobald sich der Absender verbindet.
  • Guthaben im Wallet des Absenders — USDT TRC-20 für die Auszahlungen und die Bearbeitungsgebühr sowie TRX oder gestakte Energy und Bandwidth für die Netzwerkkosten. Um das Formular zu erstellen, müssen Sie kein Wallet aufladen: Der Absender zahlt, wenn er einen Stapel sendet.
  • Bibliothek — für den Browser-Teil ist keine Installation nötig: TronLink stellt TronWeb bereit. Das Backend-Beispiel verwendet das npm-Paket tronweb. Ein SDK von Volet.com ist nicht erforderlich.
  • Website — über HTTPS ausgeliefert oder während der Entwicklung über localhost.
  • Backend und Datenbank — um jeden Stapel zu speichern und die Auszahlungen zu prüfen.
  • Blockchain-Zugang — ein TRON-Knoten oder ein gehosteter Dienst wie TronGrid. Öffentliche TronGrid-Endpunkte können einen API-Schlüssel verlangen und begrenzen die Zahl der Anfragen.

So funktioniert es​

  1. Der Absender füllt auf Ihrer Website das Auszahlungsformular aus: Empfängeradressen, USDT-Beträge und optional eine Partneradresse.
  2. Der Absender verbindet TronLink. Seinen privaten Schlüssel braucht Ihre Website nie.
  3. Ihr Frontend validiert den Stapel und liest die Bearbeitungsgebühr mit previewCommission() aus dem Contract.
  4. Ihre Website zeigt die Summe der Auszahlungen, die Bearbeitungsgebühr, den insgesamt benötigten USDT-Betrag und eine Schätzung der Netzwerkkosten.
  5. Bestätigt der Absender, prüft Ihr Frontend das USDT-Guthaben und die Allowance. Reicht die Allowance nicht, fordert TronLink den Absender zuerst auf, eine approve()-Transaktion zu signieren.
  6. Ihr Frontend prüft Gebühr, Wallet, Netzwerk und Empfänger erneut, dann fordert TronLink den Absender auf, batchPayout() zu signieren.
  7. Ihr Backend speichert den Transaktions-Hash (txid) und prüft den USDT-Transfer an jeden Empfänger, bevor es diese Auszahlung als abgeschlossen markiert.

Schlägt die Auszahlung an einen Empfänger fehl, werden die anderen nicht zwingend abgebrochen. Eine erfolgreiche Transaktion beweist also nicht, dass alle bezahlt wurden. Siehe Schritt 7: Jede Auszahlung prüfen.

Auszahlungs-Contract​

Wert
NetzwerkTRON Mainnet, Chain-ID 0x2b6653dc in TronLink
Auszahlungs-ContractTHwUFuithr9QuTFa4wBjN2zxFWjUrftV84 (TRONSCAN)
USDT-ContractTR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t
Dezimalstellen von USDT6 (1 USDT = 1.000.000 Basiseinheiten)
Netzwerkkosten bezahlt inTRX oder gestakter Energy und Bandwidth
Nulladresse (ohne Partner)T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb

Prüfen Sie vor jeder Signaturanfrage das aktive Netzwerk und das Ergebnis von usdt() des Contracts.

Der Contract bietet diese Funktionen:

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;

Er gibt die Events BatchPayout, PayoutFailed, RefundSent, PartnerNotFound und CommissionTransferFailed aus. PayoutFailed listet die Empfänger und Beträge auf, die nicht ausgezahlt wurden.

ABI des Contracts prüfen

Die Beispiele auf dieser Seite enthalten nur die Funktionen und Events, die sie verwenden. Öffnen Sie vor der Integration den Auszahlungs-Contract auf TRONSCAN, übernehmen Sie das vollständige ABI aus dem Tab Contract und gleichen Sie die Funktionssignaturen, Parametertypen und Events in Ihrem Code damit ab. Vergleichen Sie vor dem Senden echter Mittel außerdem die Token-Adresse aus usdt(), die Ergebnisse von previewCommission() und die Contract-Events mit dieser Seite.

Gebühren​

Die Bearbeitungsgebühr beträgt 0.1 USDT pro Empfänger im Stapel und kommt zu den Auszahlungsbeträgen hinzu. Ein Stapel, der 10, 20 und 30 USDT an 3 Empfänger auszahlt, braucht zum Beispiel 60 USDT für die Auszahlungen und 0.3 USDT für die Gebühr: insgesamt 60.3 USDT.

Zeigen Sie dem Absender immer den aktuellen Wert aus previewCommission(), keine in Ihrem Code berechnete Gebühr.

Der Absender zahlt außerdem die TRON-Netzwerkkosten (Energy und Bandwidth) für jede Transaktion: die Auszahlung und, falls nötig, die Freigabe. Sie werden durch gestakte Ressourcen oder verbrannte TRX gedeckt.

Partneradresse​

batchPayout() nimmt das Argument whiteLabel für das optionale Wallet eines Partners entgegen, der an der Bearbeitungsgebühr beteiligt ist. Ein Stapel funktioniert auch ohne Partner: Übergeben Sie dann die TRON-Nulladresse.

Gibt es einen Partner, übergeben Sie seine Wallet-Adresse. getPartner() zeigt, ob die Adresse ein aktiver Partner ist und wie hoch sein Anteil in Basispunkten ist, und previewCommissionSplit() zeigt, wie die Gebühr zwischen Volet.com und dem Partner aufgeteilt wird. Die Gebühr für den Absender bleibt gleich: previewCommission() hängt nicht vom Partner ab.

Um ein Partner-Wallet registrieren zu lassen, schreiben Sie an [email protected] und nennen Sie die Wallet-Adresse und das Netzwerk.

Schritt 1: Auszahlungsformular hinzufügen​

Fügen Sie die Formularelemente Ihrer Seite hinzu. Jeder Block data-payout-row ist ein Empfänger; fügen Sie Blöcke hinzu oder entfernen Sie sie, um die Zahl der Empfänger zu ändern.

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

Bevor das Formular in Produktion geht, ergänzen Sie eigenes Styling, die Verwaltung der Zeilen, Fortschrittsanzeigen und deaktivierte Schaltflächen.

Schritt 2: Wallet des Absenders verbinden​

Erstellen Sie tron-payouts.js, ein Browser-Modul, und beginnen Sie es mit der Contract-Konfiguration und der Verbindungsfunktion. Die Schritte 3 und 4 ergänzen dieselbe Datei.

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

Rufen Sie connect() nur auf, wenn der Absender Connect TronLink auswählt, nie beim Laden der Seite.

Schritt 3: Stapel und Gebühr in der Vorschau anzeigen​

Fügen Sie tron-payouts.js die Validierungs- und Vorschaufunktionen hinzu. quote() wandelt die Formularzeilen in Contract-Argumente in USDT-Basiseinheiten um und liest Gebühr, Guthaben und Allowance.

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

Zeigen Sie dem Absender total, commission und required, formatiert mit formatUsdt(), zusammen mit einer Schätzung der Netzwerkkosten. Rechnen Sie Beträge nicht mit Gleitkommazahlen um: Basiseinheiten halten sie exakt.

Empfänger vor dem Signieren prüfen

Eine Auszahlung an eine falsche Adresse lässt sich weder stornieren noch zurückholen. Zeigen Sie dem Absender vor dem Signieren jede Empfängeradresse und jeden Betrag und akzeptieren Sie nur TRON-Adressen, die USDT TRC-20 empfangen können.

Schritt 4: USDT freigeben und Stapel senden​

Fügen Sie tron-payouts.js die Sendefunktion hinzu. Sie prüft, ob sich seit der Prüfung durch den Absender nichts geändert hat, fordert eine Freigabe an, wenn die Allowance nicht reicht, wartet, bis die Freigabe solidified ist, und sendet dann 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}` };
}

Je nach bestehender Allowance signiert der Absender eine bis drei Transaktionen:

Bestehende AllowanceZu signierende Transaktionen
Reicht für den StapelAuszahlung
NullFreigabe, Auszahlung
Nicht null, aber zu niedrigAllowance auf null zurücksetzen, Freigabe, Auszahlung

Die Freigabe deckt genau den Betrag dieses Stapels ab, nie einen unbegrenzten Betrag. Jede Freigabe muss solidified sein, bevor die nächste Transaktion folgt, was meist etwa eine Minute dauert; eine approve()-Transaktion bewegt keine Mittel.

FEE_LIMIT_SUN ist das Maximum, das eine Transaktion für Netzwerkkosten ausgeben darf (300 TRX), nicht ihre tatsächlichen Kosten. Schätzen Sie die Energy, die ein Stapel braucht, und legen Sie eine passende Obergrenze fest.

Schritt 5: Schaltflächen verbinden​

Verbinden Sie das Modul mit dem Formular. Anfragen an das Wallet gehen nur von Klicks des Absenders aus, und Empfänger und Beträge stammen immer aus dem Formular.

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

Ändert der Absender das Formular nach der Vorschau, bricht send() mit „The batch or the fee changed“ ab, und der Absender ruft die Vorschau erneut auf.

Schritt 6: Stapel speichern​

Speichern Sie jeden Stapel in Ihrem Backend, bevor der Absender ihn signiert, und überschreiben Sie ihn nie. Bewahren Sie auf:

  • Ihre eigene Stapel-ID
  • das Netzwerk
  • die Adresse des Absenders
  • die Empfängerliste und die genauen Beträge in USDT-Basiseinheiten
  • die Partneradresse oder die TRON-Nulladresse
  • die angezeigte Bearbeitungsgebühr
  • die Hashes der Freigabe-Transaktionen, falls vorhanden
  • den Hash der Auszahlungstransaktion (txid)
  • den endgültigen Status jedes Empfängers

batchPayout() nimmt keine Stapel-ID an, daher existiert die Verbindung zwischen Ihrem Stapel und seiner Transaktion nur in Ihrer Datenbank. Nutzen Sie sie gegen Duplikate: Ist eine Transaktion noch ausstehend, verfolgen Sie ihren txid und senden Sie denselben Stapel nicht erneut.

Schritt 7: Jede Auszahlung prüfen​

Ein Transaktions-Hash zeigt nur, dass der Stapel übermittelt wurde. Auch ein erfolgreicher Beleg (Receipt) oder ein BatchPayout-Event beweist nicht, dass jeder Empfänger bezahlt wurde: Schlägt die Auszahlung an einen Empfänger fehl, werden die anderen nicht zwingend abgebrochen; der Contract meldet das mit PayoutFailed und kann dem Absender mit RefundSent eine Rückerstattung senden.

Ihr Backend liest die solidified Transaktionsdaten von einem SolidityNode:

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

Beide erwarten den Transaktions-Hash im Body: {"value": "<txid>"}.

Anschließend gleicht es jeden Empfänger mit den USDT-Transfer-Events der Transaktion ab. Das folgende Beispiel läuft in Node.js mit dem Paket tronweb. Es nimmt den Stapel aus Ihrer Datenbank, nicht aus dem Browser.

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

Markieren Sie nur Empfänger mit paid: true als abgeschlossen. Suchen Sie für die übrigen die Events PayoutFailed und RefundSent der Transaktion, zum Beispiel auf TRONSCAN, und prüfen Sie das Guthaben des Absenders, bevor Sie sie in einem neuen Stapel bezahlen. Senden Sie nie automatisch einen ganzen Stapel erneut.

Eine Transaktion, die noch nicht solidified ist, ist ausstehend, nicht fehlgeschlagen: Lassen Sie den Stapel ausstehend und versuchen Sie es erneut. Diese Prüfung deckt die Transfers an die Empfänger ab. In Produktion gleicht Ihr Backend außerdem die Eingabedaten der Transaktion mit dem gespeicherten Stapel ab und prüft die Partner- und Gebühren-Events. Wie Solidification funktioniert, erklärt TRON confirmation semantics.

Wichtige Hinweise​

  • Fragen Sie Absender nie nach privaten Schlüsseln oder Seed-Phrasen. Alle Signaturen erfolgen in TronLink.
  • Fordern Sie standardmäßig nie eine unbegrenzte USDT-Freigabe an.
  • Zeigen Sie vor jeder Signatur die Adresse des Auszahlungs-Contracts, die Empfänger, die Bearbeitungsgebühr und die geschätzten Netzwerkkosten.
  • TronLink ist der letzte Freigabeschritt. Für die Prüfung des Ergebnisses ist Ihre Anwendung verantwortlich.
  • Bestätigte Blockchain-Transaktionen können weder storniert noch rückgängig gemacht werden.

Wenn etwas schiefgeht​

ProblemUrsacheWas tun
„Install and unlock TronLink“TronLink ist im Browser nicht installiert oder gesperrtBitten Sie den Absender, TronLink zu installieren oder zu entsperren.
TronLink fordert zum Netzwerkwechsel aufDas Wallet ist nicht im TRON MainnetBitten Sie den Absender, den Wechsel zu bestätigen. Fordern Sie in keinem anderen Netzwerk eine Signatur an.
Der Absender lehnt Verbindung, Freigabe oder Auszahlung abDer Absender hat die Anfrage in TronLink abgebrochenSenden Sie den Stapel nicht und zeigen Sie eine klare Meldung.
„Invalid recipient address“ oder „Invalid USDT amount“Eine Formularzeile enthält einen FehlerSperren Sie Vorschau und Senden, bis der Absender diesen Empfänger korrigiert.
„Not enough USDT in the sender wallet“Das Guthaben ist kleiner als Auszahlungen plus GebührZeigen Sie den benötigten Gesamtbetrag und die für Netzwerkkosten nötigen TRX.
Eine Transaktion scheitert mit einem Out-of-Energy-FehlerDer Absender hat zu wenig TRX oder Energy, oder das Gebührenlimit ist für den Stapel zu niedrigBitten Sie den Absender, TRX aufzuladen oder für Energy zu staken, oder erhöhen Sie das Gebührenlimit für große Stapel.
„Transaction is still pending“Freigabe oder Auszahlung ist noch nicht solidifiedVerfolgen Sie den ursprünglichen txid. Senden Sie dieselbe Transaktion nicht erneut.
Die Transaktion war erfolgreich, aber ein Empfänger hat kein USDTDie Auszahlung an diesen Empfänger ist fehlgeschlagenMarkieren Sie nur geprüfte Transfers als abgeschlossen. Gleichen Sie fehlgeschlagene Empfänger und eine etwaige Rückerstattung vor einem neuen Stapel ab.
„The batch or the fee changed“Formular, Gebühr oder Partnereinstellungen haben sich nach der Vorschau geändertRufen Sie die Vorschau erneut auf und bitten Sie den Absender, die neuen Summen zu prüfen.
„The payout contract is paused“Auszahlungen sind im Contract vorübergehend gestopptSenden Sie nicht. Versuchen Sie es später erneut.
TronGrid gibt Fehler oder Rate-Limit-Antworten zurückÖffentliche Endpunkte ohne API-Schlüssel begrenzen die Zahl der AnfragenVerwenden Sie einen TronGrid-API-Schlüssel oder einen eigenen Knoten und versuchen Sie es erneut.