Zum Hauptinhalt springen

USDT-BEP-20-Auszahlungen auf BNB Smart Chain 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 BEP-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 BNB Smart Chain Mainnet. Für andere Netzwerke siehe TRON und Ethereum.

Bevor Sie beginnen​

  • Wallet des Absenders — MetaMask oder ein anderes EIP-1193-kompatibles Browser-Wallet. Die Beispiele verwenden MetaMask in Google Chrome.
  • Guthaben im Wallet des Absenders — USDT BEP-20 für die Auszahlungen und die Bearbeitungsgebühr sowie BNB für die Netzwerkgebühren. Um das Formular zu erstellen, müssen Sie kein Wallet aufladen: Der Absender zahlt, wenn er einen Stapel sendet.
  • Bibliothek — ethers.js v6. 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.
  • RPC-Anbieter — ein BNB-Smart-Chain-Knoten oder ein gehosteter Dienst für die Prüfung im Backend.

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 sein Wallet. 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 Netzwerkgebühr.
  5. Bestätigt der Absender, prüft Ihr Frontend das USDT-Guthaben und die Allowance. Reicht die Allowance nicht, fordert das Wallet den Absender zuerst auf, eine approve()-Transaktion zu signieren.
  6. Ihr Frontend prüft Gebühr, Wallet, Netzwerk und Empfänger erneut, dann fordert das Wallet 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
NetzwerkBNB Smart Chain Mainnet, Chain-ID 56 (0x38)
Auszahlungs-Contract0x765A0cd00e07C23d1f760BDc794940967Bc6ccC7 (BscScan)
USDT-Contract0x55d398326f99059fF775485246999027B3197955 (Binance-Peg USDT, angezeigt als BSC-USD)
Dezimalstellen von USDT18 (1 USDT = 10^18 Basiseinheiten)
Netzwerkgebühr bezahlt inBNB
Nulladresse (ohne Partner)0x0000000000000000000000000000000000000000

Dieselbe Adresse des Auszahlungs-Contracts gibt es auch auf Ethereum. Die beiden Deployments sind nicht austauschbar: Prüfen Sie vor jeder Signaturanfrage die Chain-ID des Wallets 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 BscScan, ü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 Dezimalstellen des Tokens, 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 Netzwerkgebühr von BNB Smart Chain in BNB für jede Transaktion: die Auszahlung und, falls nötig, die Freigabe.

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

Installieren Sie ethers.js:

npm install ethers@^6

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

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

import { ethers } from 'ethers';

const CHAIN_ID = 56n;
const PAYOUT_ADDRESS = '0x765A0cd00e07C23d1f760BDc794940967Bc6ccC7';
const USDT_ADDRESS = '0x55d398326f99059fF775485246999027B3197955';
export const USDT_DECIMALS = 18;
const EXPLORER_TX = 'https://bscscan.com/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 BNB Smart Chain 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.');
}
}

Rufen Sie connect() nur auf, wenn der Absender Connect wallet auswählt, nie beim Laden der Seite. Ist das Wallet in einem anderen Netzwerk, bitten Sie den Absender, zu BNB Smart Chain zu wechseln.

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

Fügen Sie bnb-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 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,18})?$/.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)
};
}

Zeigen Sie dem Absender total, commission und required, formatiert mit ethers.formatUnits(value, USDT_DECIMALS), zusammen mit einer Schätzung der Netzwerkgebühr in BNB. Rechnen Sie Beträge nicht mit Gleitkommazahlen um: parseUnits() hält 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 BNB-Smart-Chain-Adressen, die USDT BEP-20 empfangen können.

Schritt 4: USDT freigeben und Stapel senden​

Fügen Sie bnb-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, 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 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) {
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 };
}

Je nach bestehender Allowance signiert der Absender eine oder zwei Transaktionen:

Bestehende AllowanceZu signierende Transaktionen
Reicht für den StapelAuszahlung
Zu niedrigFreigabe, Auszahlung

Die Freigabe deckt genau den Betrag dieses Stapels ab, nie einen unbegrenzten Betrag. Sie muss vor der Auszahlungstransaktion bestätigt sein; eine approve()-Transaktion bewegt keine Mittel.

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 { ethers } from 'ethers';
import { USDT_DECIMALS, connect, quote, send } from './bnb-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)));
});
}

Ä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 und die Chain-ID
  • die Adresse des Absenders
  • die Empfängerliste und die genauen Beträge in USDT-Basiseinheiten
  • die Partneradresse oder die 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 gleicht jeden Empfänger mit den USDT-Transfer-Logs der Transaktion ab. Das folgende Beispiel läuft in Node.js mit ethers v6. Es nimmt den Stapel aus Ihrer Datenbank, nicht aus dem Browser.

import { ethers } from 'ethers';
import { PAYOUT_ABI } from './bnb-payouts.js';

const provider = new ethers.JsonRpcProvider(process.env.BSC_RPC_URL);
const PAYOUT_ADDRESS = '0x765A0cd00e07C23d1f760BDc794940967Bc6ccC7';
const USDT_ADDRESS = '0x55d398326f99059fF775485246999027B3197955';

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

Markieren Sie nur Empfänger mit paid: true als abgeschlossen. Gleichen Sie für die übrigen die Events PayoutFailed und RefundSent ab und prüfen Sie das Guthaben des Absenders, bevor Sie sie in einem neuen Stapel bezahlen. Senden Sie nie automatisch einen ganzen Stapel 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, prüft die Partner- und Gebühren-Events und behandelt einen RPC-Anbieter, der nicht erreichbar ist oder keine Finalitätsdaten liefert: Lassen Sie den Stapel ausstehend und versuchen Sie es erneut.

Wichtige Hinweise​

  • Fragen Sie Absender nie nach privaten Schlüsseln oder Seed-Phrasen. Alle Signaturen erfolgen im Wallet des Absenders.
  • 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ätzte Netzwerkgebühr.
  • Das Wallet 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 MetaMask“Kein EIP-1193-Wallet im Browser, oder es ist gesperrtBitten Sie den Absender, das Wallet zu installieren oder zu entsperren.
„Select BNB Smart Chain in your wallet“Das Wallet ist in einem anderen NetzwerkBitten Sie den Absender, zu BNB Smart Chain zu wechseln und sich erneut zu verbinden. Fordern Sie in keinem anderen Netzwerk eine Signatur an.
Der Absender lehnt Verbindung, Freigabe oder Auszahlung abDer Absender hat die Anfrage im Wallet 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 Netzwerkgebühren nötigen BNB.
Die Freigabe ist noch ausstehendDie Freigabe-Transaktion ist noch nicht bestätigtWarten Sie die Bestätigung ab. Gehen Sie nie allein aufgrund des Transaktions-Hashs von einer Freigabe aus.
Die Auszahlungstransaktion ist noch ausstehendDie Transaktion ist noch nicht in einem finalisierten BlockVerfolgen Sie den ursprünglichen txid. Senden Sie denselben Stapel 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.