Ana içeriğe geç

Ethereum'da USDT ERC-20 ödemelerini entegre etme

Sitenize bir toplu ödeme formu ekleyin: gönderen kendi cüzdanını bağlar, alıcıları ve USDT tutarlarını girer, komisyonu kontrol eder ve toplu işlemi imzalar. Volet.com ödeme sözleşmesi USDT ERC-20'yi gönderenin cüzdanından doğrudan alıcıların cüzdanlarına gönderir; bu nedenle fonlar hiçbir zaman bir Volet.com hesabından geçmez.

Bu kılavuz Ethereum Mainnet'i kapsar. Diğer ağlar için TRON ve BNB Smart Chain sayfalarına bakın.

Başlamadan önce​

  • Gönderen cüzdanı — MetaMask veya EIP-1193 uyumlu başka bir tarayıcı cüzdanı. Örneklerde Google Chrome'da MetaMask kullanılır.
  • Gönderen cüzdanındaki fonlar — ödemeler ve işlem komisyonu için USDT ERC-20, ayrıca ağ ücretleri için ETH. Formu oluşturmak için herhangi bir cüzdana para yatırmanız gerekmez: toplu işlemi gönderirken ödemeyi gönderen yapar.
  • Kütüphane — ethers.js v6. Volet.com SDK'sı gerekmez.
  • Web sitesi — HTTPS üzerinden veya geliştirme sırasında localhost üzerinden sunulur.
  • Arka uç ve veritabanı — her toplu işlemi saklamak ve ödemeleri doğrulamak için.
  • RPC sağlayıcısı — arka uçta doğrulama için bir Ethereum Mainnet düğümü veya barındırılan hizmet.

Nasıl çalışır​

  1. Gönderen sitenizdeki ödeme formunu doldurur: alıcı adresleri, USDT tutarları ve isteğe bağlı olarak bir iş ortağı adresi.
  2. Gönderen cüzdanını bağlar. Siteniz hiçbir zaman onun özel anahtarına ihtiyaç duymaz.
  3. Ön ucunuz toplu işlemi doğrular ve işlem komisyonunu previewCommission() ile sözleşmeden okur.
  4. Siteniz ödemelerin toplamını, işlem komisyonunu, gereken toplam USDT'yi ve ağ ücretinin tahminini gösterir.
  5. Gönderen onayladığında ön ucunuz USDT bakiyesini ve harcama iznini (allowance) kontrol eder. İzin yetersizse cüzdan gönderenden önce bir approve() işlemi imzalamasını ister.
  6. Ön ucunuz komisyonu, cüzdanı, ağı ve alıcıları yeniden kontrol eder, ardından cüzdan gönderenden batchPayout() işlemini imzalamasını ister.
  7. Arka ucunuz işlem hash'ini (txid) kaydeder ve her alıcının USDT transferini doğruladıktan sonra o ödemeyi tamamlandı olarak işaretler.

Bir alıcıya yapılan ödeme başarısız olursa diğerleri her zaman iptal edilmez; bu yüzden başarılı bir işlem herkese ödeme yapıldığını kanıtlamaz. Bkz. Adım 7: Her ödemeyi doğrulayın.

Ödeme sözleşmesi​

Değer
AğEthereum Mainnet, chain ID 1 (0x1)
Ödeme sözleşmesi0x765A0cd00e07C23d1f760BDc794940967Bc6ccC7 (Etherscan)
USDT sözleşmesi0xdAC17F958D2ee523a2206206994597C13D831ec7
USDT ondalık basamakları6 (1 USDT = 1.000.000 temel birim)
Ağ ücretinin ödendiği varlıkETH
Sıfır adres (iş ortağı yok)0x0000000000000000000000000000000000000000

Aynı ödeme sözleşmesi adresi BNB Smart Chain'de de bulunur. İki dağıtım birbirinin yerine kullanılamaz: imza istemeden önce her zaman cüzdanın chain ID'sini ve sözleşmenin usdt() sonucunu kontrol edin.

Sözleşme şu fonksiyonları sunar:

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;

Sözleşme BatchPayout, PayoutFailed, RefundSent, PartnerNotFound ve CommissionTransferFailed olaylarını yayar. PayoutFailed, ödenmeyen alıcıları ve tutarları listeler.

Sözleşmenin ABI'sini kontrol edin

Bu sayfadaki örnekler yalnızca kullandıkları fonksiyonları ve olayları içerir. Entegrasyondan önce ödeme sözleşmesini Etherscan üzerinde açın, tam ABI'yi Contract sekmesinden alın ve kodunuzdaki fonksiyon imzalarını, parametre türlerini ve olayları bununla karşılaştırın. Gerçek fon göndermeden önce usdt() tarafından döndürülen token adresini, token'ın ondalık basamaklarını, previewCommission() sonuçlarını ve sözleşme olaylarını da bu sayfayla karşılaştırın.

Ücretler​

İşlem komisyonu, ödeme tutarlarına ek olarak toplu işlemdeki alıcı başına 0.1 USDT'dir. Örneğin 3 alıcıya 10, 20 ve 30 USDT ödeyen bir toplu işlem için ödemelere 60 USDT ve komisyona 0.3 USDT gerekir: toplam 60.3 USDT.

Gönderene her zaman kodunuzda hesaplanan bir komisyonu değil, previewCommission() tarafından döndürülen güncel değeri gösterin.

Gönderen ayrıca her işlem için Ethereum ağ ücretini ETH olarak öder: ödeme ve gerekirse onay.

İş ortağı adresi​

batchPayout(), işlem komisyonunu paylaşan isteğe bağlı bir iş ortağı cüzdanı için whiteLabel bağımsız değişkenini alır. Toplu işlem iş ortağı olmadan da çalışır: sıfır adresi iletin.

İş ortağı varsa onun cüzdan adresini iletin. getPartner() adresin etkin bir iş ortağı olup olmadığını ve baz puan cinsinden payını, previewCommissionSplit() ise komisyonun Volet.com ile iş ortağı arasında nasıl bölündüğünü gösterir. Gönderenin ödediği komisyon değişmez: previewCommission() iş ortağına bağlı değildir.

Bir iş ortağı cüzdanını kaydettirmek için cüzdan adresini ve ağı belirterek [email protected] adresine yazın.

Adım 1: Ödeme formunu ekleyin​

ethers.js'i yükleyin:

npm install ethers@^6

Form öğelerini sayfanıza ekleyin. Her data-payout-row bloğu bir alıcıdır; alıcı sayısını değiştirmek için blok ekleyin veya kaldırın.

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

Formu canlıya almadan önce kendi stillerinizi, satır yönetimini, ilerleme göstergelerini ve devre dışı düğme durumlarını ekleyin.

Adım 2: Gönderen cüzdanını bağlayın​

Tarayıcı tarafında çalışan bir modül olarak ethereum-payouts.js dosyasını oluşturun ve sözleşme yapılandırması ile bağlantı fonksiyonuyla başlatın. Adım 3 ve 4 aynı dosyaya kod ekler.

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

connect() fonksiyonunu yalnızca gönderen Connect wallet seçeneğini seçtiğinde çağırın, asla sayfa yüklenirken çağırmayın. Cüzdan başka bir ağdaysa gönderenden Ethereum Mainnet'e geçmesini isteyin.

Adım 3: Toplu işlemi ve komisyonu önizleyin​

Doğrulama ve önizleme fonksiyonlarını ethereum-payouts.js dosyasına ekleyin. quote() form satırlarını USDT temel birimlerinde sözleşme bağımsız değişkenlerine dönüştürür ve komisyonu, bakiyeyi ve harcama iznini okur.

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

Gönderene ethers.formatUnits(value, USDT_DECIMALS) ile biçimlendirilmiş total, commission ve required değerlerini ETH cinsinden ağ ücreti tahminiyle birlikte gösterin. Tutarları kayan noktalı aritmetikle dönüştürmeyin: parseUnits() onları kesin tutar.

İmzalamadan önce alıcıları kontrol edin

Yanlış bir adrese gönderilen ödeme iptal edilemez ve geri alınamaz. Gönderen imzalamadan önce ona her alıcı adresini ve tutarı gösterin ve yalnızca USDT ERC-20 alabilen Ethereum adreslerini kabul edin.

Adım 4: USDT'yi onaylayın ve toplu işlemi gönderin​

Gönderme fonksiyonunu ethereum-payouts.js dosyasına ekleyin. Fonksiyon, gönderen toplu işlemi incelediğinden beri hiçbir şeyin değişmediğini kontrol eder, harcama izni yetersizse onay ister ve ardından batchPayout() işlemini gönderir.

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

Mevcut harcama iznine bağlı olarak gönderen bir ila üç işlem imzalar:

Mevcut harcama izniİmzalanacak işlemler
Toplu işlem için yeterliÖdeme
SıfırOnay, ödeme
Sıfır değil ama yetersizİzni sıfıra sıfırlama, onay, ödeme

Onay yalnızca bu toplu işlemin tutarını kapsar, asla sınırsız bir tutarı değil. Her onayın bir sonraki işlemden önce onaylanmış olması gerekir; approve() işlemi fon taşımaz.

Adım 5: Düğmeleri bağlayın​

Modülü forma bağlayın. Cüzdana yapılan istekler yalnızca gönderenin tıklamalarıyla başlar; alıcılar ve tutarlar her zaman formdan alınır.

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

Gönderen önizlemeden sonra formu değiştirirse send() "The batch or the fee changed" hatasıyla durur ve gönderen önizlemeyi yeniden yapar.

Adım 6: Toplu işlemi kaydedin​

Her toplu işlemi gönderen imzalamadan önce arka ucunuzda saklayın ve asla üzerine yazmayın. Şunları saklayın:

  • kendi toplu işlem kimliğiniz
  • ağ ve chain ID
  • gönderen adresi
  • alıcı listesi ve USDT temel birimlerinde kesin tutarlar
  • iş ortağı adresi veya sıfır adres
  • teklif edilen işlem komisyonu
  • varsa onay işlemlerinin hash'leri
  • ödeme işleminin hash'i (txid)
  • her alıcının nihai durumu

batchPayout() bir toplu işlem kimliği kabul etmez; bu nedenle toplu işleminiz ile işlemi arasındaki bağlantı yalnızca veritabanınızda bulunur. Bunu mükerrer gönderimleri önlemek için kullanın: bir işlem hâlâ beklemedeyse txid değerini takip edin ve aynı toplu işlemi yeniden göndermeyin.

Adım 7: Her ödemeyi doğrulayın​

İşlem hash'i yalnızca toplu işlemin gönderildiğini gösterir. Başarılı bir makbuz (receipt) veya BatchPayout olayı da her alıcıya ödeme yapıldığını kanıtlamaz: bir alıcıya yapılan ödeme başarısız olursa diğerleri her zaman iptal edilmez; sözleşme bunu PayoutFailed ile bildirir ve gönderene RefundSent ile iade yapabilir.

Arka ucunuz her alıcıyı işlemdeki USDT Transfer loglarıyla karşılaştırır. Aşağıdaki örnek Node.js'te ethers v6 ile çalışır. Toplu işlemi tarayıcıdan değil, veritabanınızdan alır.

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

Yalnızca paid: true olan alıcıları tamamlandı olarak işaretleyin. Diğerleri için PayoutFailed ve RefundSent olaylarının mutabakatını yapın ve onlara yeni bir toplu işlemle ödeme yapmadan önce gönderenin bakiyesini kontrol edin. Hiçbir zaman bir toplu işlemin tamamını otomatik olarak yeniden göndermeyin.

Bu kontrol alıcılara yapılan transferleri kapsar. Canlı ortamda arka ucunuz ayrıca işlemin giriş verilerini kayıtlı toplu işlemle karşılaştırır, iş ortağı ve komisyon olaylarını kontrol eder ve RPC sağlayıcısının erişilemediği veya kesinlik verisi döndürmediği durumları ele alır: toplu işlemi beklemede tutun ve yeniden deneyin.

Önemli notlar​

  • Gönderenlerden asla özel anahtar veya kurtarma ifadesi (seed phrase) istemeyin. Tüm imzalar gönderenin cüzdanında atılır.
  • Varsayılan olarak asla sınırsız USDT onayı istemeyin.
  • Her imzadan önce ödeme sözleşmesinin adresini, alıcıları, işlem komisyonunu ve ağ ücreti tahminini gösterin.
  • Cüzdan son onay adımıdır. Sonucu doğrulamak uygulamanızın sorumluluğundadır.
  • Blokzincirde onaylanmış işlemler iptal edilemez ve geri alınamaz.

Bir sorun olursa​

SorunNedenNe yapmalı
"Install and unlock MetaMask"Tarayıcıda EIP-1193 cüzdanı yok veya kilitliGönderenden cüzdanı yüklemesini veya kilidini açmasını isteyin.
"Select Ethereum Mainnet in your wallet"Cüzdan başka bir ağdaGönderenden Ethereum Mainnet'e geçip yeniden bağlanmasını isteyin. Başka bir ağda imza istemeyin.
Gönderen bağlantıyı, onayı veya ödemeyi reddediyorGönderen isteği cüzdanda iptal ettiToplu işlemi göndermeyin ve anlaşılır bir mesaj gösterin.
"Invalid recipient address" veya "Invalid USDT amount"Bir form satırında hata varGönderen o alıcıyı düzeltene kadar önizlemeyi ve gönderimi engelleyin.
"Not enough USDT in the sender wallet"Bakiye, ödemeler ile komisyonun toplamından azGereken toplamı ve ağ ücretleri için gereken ETH'yi gösterin.
Onay hâlâ beklemedeOnay işlemi henüz onaylanmadıOnayı bekleyin. Onayı asla yalnızca işlem hash'ine bakarak gerçekleşmiş saymayın.
Ödeme işlemi hâlâ beklemedeİşlem henüz kesinleşmiş bir blokta değilOrijinal txid değerini takip edin. Aynı toplu işlemi yeniden yayınlamayın.
İşlem başarılı oldu ama bir alıcıda USDT yokO alıcıya yapılan ödeme başarısız olduYalnızca doğrulanmış transferleri tamamlandı olarak işaretleyin. Yeni bir toplu işlemden önce başarısız alıcıların ve varsa iadenin mutabakatını yapın.
"The batch or the fee changed"Önizlemeden sonra form, komisyon veya iş ortağı ayarları değiştiÖnizlemeyi yeniden yapın ve gönderenden yeni toplamları kontrol etmesini isteyin.
"The payout contract is paused"Sözleşmede ödemeler geçici olarak durdurulduGöndermeyin. Daha sonra yeniden deneyin.