Batch-Zahlungen

Eine Solana-Transaktion ist ein Container, der eine oder mehrere Anweisungen enthält. Jede Anweisung ist eine Operation – Token übertragen, ein Konto erstellen, ein Programm aufrufen. Das Netzwerk führt alle Anweisungen in einer Transaktion sequenziell und atomisch aus: Entweder gelingt jede Anweisung, oder die gesamte Transaktion schlägt fehl und wird zurückgesetzt.

Das bedeutet, dass Sie mehrere Überweisungen in eine einzige Transaktion packen können. Anstatt drei separate Transaktionen zu senden, um drei Empfänger zu bezahlen, senden Sie eine Transaktion mit drei Überweisungsanweisungen. Das ist schneller (eine Bestätigung anstatt drei) und günstiger (eine Grundgebühr anstatt drei). Hier ist ein anschauliches Beispiel dafür, wie Zahlungen (in diesem Bild als „Drops" bezeichnet) in einer einzigen Transaktion gebündelt werden und mehrere Transaktionen gesendet werden, um den größeren Batch zu verarbeiten.

Batch-Zahlungen-Diagramm

Quelle: QuickNode - How to Send Bulk Transactions on Solana

Weitere Informationen zu Transaktionen und Anweisungen finden Sie in den Leitfäden Transaktionen und Anweisungen.

Die folgende Anleitung zeigt, wie Sie mehrere Überweisungsanweisungen in eine einzige Transaktion für Batch-Zahlungen laden.

Anweisungen in einer einzigen Transaktion bündeln

Eine Solana-Transaktion kann mehrere Überweisungen an verschiedene Empfänger enthalten. Sie signieren einmal, zahlen eine Transaktionsgebühr, und alle Überweisungen werden zusammen abgewickelt. Wenn eine Überweisung fehlschlägt, wird die gesamte Transaktion abgelehnt.

Siehe Wie Zahlungen auf Solana funktionieren für grundlegende Zahlungskonzepte.

Das Bündeln mehrerer Überweisungen erfordert das separate Erstellen jeder Anweisung und anschließend das Kombinieren in einer einzigen Transaktion.

Die folgenden Schritte zeigen den grundlegenden Ablauf. Siehe die Demo für vollständigen ausführbaren Code.

Token-Konten ableiten

Leiten Sie zunächst die Adressen der Associated Token Accounts (ATA) für den Absender und jeden Empfänger ab. ATAs sind deterministische Adressen, die auf der Wallet und dem Mint basieren.

Transfer-Anweisungen erstellen

Erstellen Sie für jeden Empfänger eine separate Transfer-Anweisung. Jede Anweisung gibt Folgendes an:

Adresse des Quell-Token-Kontos
Adresse des Ziel-Token-Kontos
Autorisierung (Adresse des Eigentümers des Quell-Token-Kontos)
Betrag in Basiseinheiten (angepasst an die Dezimalstellen des Mints)

Als einzelne Transaktion senden

Fügen Sie alle Transfer-Anweisungen in eine einzige Transaktion ein. Dadurch werden alle Transfers atomar ausgeführt – entweder alle Transfers sind erfolgreich oder die gesamte Transaktion schlägt fehl.

Guthaben überprüfen

Überprüfen Sie nach dem Batch-Transfer die Token-Guthaben aller Beteiligten mithilfe des splToken-Helpers.

Token-Konten ableiten

Leiten Sie zunächst die Adressen der Associated Token Accounts (ATA) für den Absender und jeden Empfänger ab. ATAs sind deterministische Adressen, die auf der Wallet und dem Mint basieren.

Transfer-Anweisungen erstellen

Erstellen Sie für jeden Empfänger eine separate Transfer-Anweisung. Jede Anweisung gibt Folgendes an:

Adresse des Quell-Token-Kontos
Adresse des Ziel-Token-Kontos
Autorisierung (Adresse des Eigentümers des Quell-Token-Kontos)
Betrag in Basiseinheiten (angepasst an die Dezimalstellen des Mints)

Als einzelne Transaktion senden

Guthaben überprüfen

Überprüfen Sie nach dem Batch-Transfer die Token-Guthaben aller Beteiligten mithilfe des splToken-Helpers.

Batch Payments

const [senderAta] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: sender.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const [recipient1Ata] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient1.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const [recipient2Ata] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient2.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

Demo



// Generate keypairs for sender and two recipients
const sender = (await generateKeypair()).signer;
const recipient1 = (await generateKeypair()).signer;
const recipient2 = (await generateKeypair()).signer;

console.log("Sender Address:", sender.address);
console.log("Recipient 1 Address:", recipient1.address);
console.log("Recipient 2 Address:", recipient2.address);

// Demo Setup: Create client, mint account, token accounts, and fund with initial tokens
const { client, mint } = await demoSetup(sender, recipient1, recipient2);

console.log("\nMint Address:", mint.address);

// Derive the Associated Token Accounts addresses (ATAs) for sender and recipients
const [senderAta] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: sender.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const [recipient1Ata] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient1.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const [recipient2Ata] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient2.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

console.log("Sender Token Account:", senderAta.toString());
console.log("Recipient 1 Token Account:", recipient1Ata.toString());
console.log("Recipient 2 Token Account:", recipient2Ata.toString());

// =============================================================================
// Batch Token Payment Demo
// =============================================================================

// Create instructions to transfer tokens from sender to both recipients
// Transferring 250,000 base units = 0.25 tokens (with 6 decimals) to each
const transfer1Instruction = getTransferInstruction({
  source: senderAta,
  destination: recipient1Ata,
  authority: sender.address,
  amount: 250_000n // 0.25 tokens
});

const transfer2Instruction = getTransferInstruction({
  source: senderAta,
  destination: recipient2Ata,
  authority: sender.address,
  amount: 250_000n // 0.25 tokens
});

// Prepare and send both transfers in a single transaction using @solana/client
const signature = await client.transaction.prepareAndSend({
  authority: sender,
  instructions: [transfer1Instruction, transfer2Instruction],
  version: 0
});

console.log("\n=== Batch Token Payment Complete ===");
console.log("Transaction Signature:", signature.toString());

// Fetch final token account balances using @solana/client SPL token helper
const splToken = client.splToken({
  mint: mint.address,
  tokenProgram: "auto"
});

const senderBalance = await splToken.fetchBalance(sender.address);
const recipient1Balance = await splToken.fetchBalance(recipient1.address);
const recipient2Balance = await splToken.fetchBalance(recipient2.address);

console.log("\nSender Token Account Balance:", senderBalance);
console.log("Recipient 1 Token Account Balance:", recipient1Balance);
console.log("Recipient 2 Token Account Balance:", recipient2Balance);

// =============================================================================
// Demo Setup Helper Function
// =============================================================================

Console

Click to execute the code.

Demo



// Generate keypairs for sender and two recipients
const sender = (await generateKeypair()).signer;
const recipient1 = (await generateKeypair()).signer;
const recipient2 = (await generateKeypair()).signer;

console.log("Sender Address:", sender.address);
console.log("Recipient 1 Address:", recipient1.address);
console.log("Recipient 2 Address:", recipient2.address);

// Demo Setup: Create client, mint account, token accounts, and fund with initial tokens
const { client, mint } = await demoSetup(sender, recipient1, recipient2);

console.log("\nMint Address:", mint.address);

// Derive the Associated Token Accounts addresses (ATAs) for sender and recipients
const [senderAta] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: sender.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const [recipient1Ata] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient1.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const [recipient2Ata] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient2.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

console.log("Sender Token Account:", senderAta.toString());
console.log("Recipient 1 Token Account:", recipient1Ata.toString());
console.log("Recipient 2 Token Account:", recipient2Ata.toString());

// =============================================================================
// Batch Token Payment Demo
// =============================================================================

// Create instructions to transfer tokens from sender to both recipients
// Transferring 250,000 base units = 0.25 tokens (with 6 decimals) to each
const transfer1Instruction = getTransferInstruction({
  source: senderAta,
  destination: recipient1Ata,
  authority: sender.address,
  amount: 250_000n // 0.25 tokens
});

const transfer2Instruction = getTransferInstruction({
  source: senderAta,
  destination: recipient2Ata,
  authority: sender.address,
  amount: 250_000n // 0.25 tokens
});

// Prepare and send both transfers in a single transaction using @solana/client
const signature = await client.transaction.prepareAndSend({
  authority: sender,
  instructions: [transfer1Instruction, transfer2Instruction],
  version: 0
});

console.log("\n=== Batch Token Payment Complete ===");
console.log("Transaction Signature:", signature.toString());

// Fetch final token account balances using @solana/client SPL token helper
const splToken = client.splToken({
  mint: mint.address,
  tokenProgram: "auto"
});

const senderBalance = await splToken.fetchBalance(sender.address);
const recipient1Balance = await splToken.fetchBalance(recipient1.address);
const recipient2Balance = await splToken.fetchBalance(recipient2.address);

console.log("\nSender Token Account Balance:", senderBalance);
console.log("Recipient 1 Token Account Balance:", recipient1Balance);
console.log("Recipient 2 Token Account Balance:", recipient2Balance);

// =============================================================================
// Demo Setup Helper Function
// =============================================================================

Console

Click to execute the code.

Skalierung mit Transaktionsplanung

Eine einzelne Transaktion hat Größenbeschränkungen – etwa 1232 Bytes. Bei großen Batch-Operationen (Gehaltsabrechnung für Hunderte von Mitarbeitern, Massen-Airdrops) überschreiten Sie dieses Limit und müssen die Arbeit auf mehrere Transaktionen aufteilen.

Obwohl Sie gerne Ihre eigene Transaktionsverteilungslogik erstellen können, übernimmt das @solana/instruction-plans-Paket (Teil von Solana Kit) dies auf zwei Ebenen:

Anweisungspläne definieren Ihre Operationen und deren Reihenfolgebeschränkungen:

Sequenziell — Anweisungen, die in einer bestimmten Reihenfolge ausgeführt werden müssen
Parallel — Anweisungen, die in beliebiger Reihenfolge ausgeführt werden können
Unteilbar — Anweisungen, die in derselben Transaktion zusammenbleiben müssen

Transaktionspläne werden aus Anweisungsplänen generiert. Der Planer packt Anweisungen intelligent in optimal dimensionierte Transaktionen und berücksichtigt dabei Ihre Reihenfolgebeschränkungen. Der resultierende Transaktionsplan kann dann:

Ausgeführt werden — signiert und an das Netzwerk gesendet, wobei parallele Transaktionen gleichzeitig gesendet werden
Simuliert werden — Testlauf gegen das Netzwerk zur Überprüfung vor dem Senden
Serialisiert werden — zu Base64 kompiliert für externe Signaturdienste oder Mehrparteien-Workflows

Dieser zweistufige Ansatz ermöglicht es Ihnen, in Operationen zu denken ("Überweisung an Alice, dann Überweisung an Bob"), während die Bibliothek die Mechanik der Transaktionsgröße, des Packens und der parallelen Ausführung übernimmt.

Batch-Zahlungen

Anweisungen in einer einzigen Transaktion bündeln

Token-Konten ableiten

Transfer-Anweisungen erstellen

Als einzelne Transaktion senden

Guthaben überprüfen

Token-Konten ableiten

Transfer-Anweisungen erstellen

Als einzelne Transaktion senden

Guthaben überprüfen

Demo

Skalierung mit Transaktionsplanung

Inhaltsverzeichnis