> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# So senden Sie Solana-Transaktionen
> Schritt-für-Schritt-Anleitung zum Aufbau robuster, produktionsreifer Solana-Transaktions-Workflows. Lernen Sie Rechenoptimierung, Prioritätsgebühren und Bestätigungsstrategien.
Dies ist der **Basis**-Transaktionspfad — pro Sendung abgerechnet und am besten, wenn Zuverlässigkeit wichtiger ist als reine Geschwindigkeit (Zahlungen, Wallets, Apps). Wenn Sie handeln und die geringste Latenz benötigen, verwenden Sie stattdessen [Helius Sender](/docs/de/sending-transactions/sender).
Eigene Transaktionslogik zu entwickeln, ist der beste Weg, um maximale Leistung, Kontrolle und Zuverlässigkeit für Ihre Anwendung zu gewährleisten. Während das [Helius SDK](/docs/de/sdks) einen praktischen Einstieg bietet, ist das Verständnis und die Implementierung dieses manuellen Workflows für Produktionssysteme sehr zu empfehlen.
Diese Anleitung führt Sie durch die notwendigen Schritte, um Ihre eigene Lösung zu entwickeln.
### Der manuelle Workflow
Das manuelle Senden einer Transaktion umfasst folgende Schritte:
Stellen Sie Ihre Anweisungen zusammen und signieren Sie die Transaktion, damit sie simuliert werden kann.
Simulieren Sie die Transaktion, um die genauen CUs zu bestimmen und fügen Sie einen kleinen Puffer hinzu.
Holen Sie eine Gebührenabschätzung von der Helius Priority Fee API ein und fügen Sie sie Ihrer Transaktion hinzu.
Senden Sie die endgültige Transaktion und implementieren Sie eine robuste Polling-Strategie, um die Bestätigung zu bearbeiten.
Die Helius SDKs sind Open Source. Sie können den zugrunde liegenden Code für die `sendSmartTransaction`-Methode in unserem [TypeScript SDK](https://github.com/helius-labs/helius-sdk) und [Rust SDK](https://github.com/helius-labs/helius-rust-sdk) ansehen, um eine produktionsreife Implementierung dieses Workflows zu sehen.
### 1. Erstellen der anfänglichen Transaktion
Zuerst sammeln Sie alle Anweisungen, die Sie in Ihre Transaktion aufnehmen möchten. Erstellen Sie dann ein `Transaction`- oder `VersionedTransaction`-Objekt. Sie müssen auch einen aktuellen Blockhash abrufen.
Dieses Beispiel bereitet eine versionierte Transaktion vor. In diesem Stadium müssen Sie sie auch signieren, damit sie im nächsten Schritt simuliert werden kann.
```typescript theme={"system"}
import {
Connection,
Keypair,
TransactionMessage,
VersionedTransaction,
SystemProgram,
LAMPORTS_PER_SOL,
} from "@solana/web3.js";
const connection = new Connection("YOUR_RPC_URL");
const fromKeypair = Keypair.generate(); // Assume this is funded
const toPubkey = Keypair.generate().publicKey;
// 1. Build your instructions
const instructions = [
SystemProgram.transfer({
fromPubkey: fromKeypair.publicKey,
toPubkey: toPubkey,
lamports: 0.001 * LAMPORTS_PER_SOL,
}),
];
// 2. Get a recent blockhash
const { blockhash } = await connection.getLatestBlockhash();
// 3. Compile the transaction message
const messageV0 = new TransactionMessage({
payerKey: fromKeypair.publicKey,
recentBlockhash: blockhash,
instructions,
}).compileToV0Message();
// 4. Create and sign the transaction
const transaction = new VersionedTransaction(messageV0);
transaction.sign([fromKeypair]);
```
### 2. Optimierung der Nutzung von Recheneinheiten (CU)
Um unnötige Gebühren zu vermeiden oder das Scheitern Ihrer Transaktion zu verhindern, sollten Sie das Limit für die Recheneinheiten (CU) so präzise wie möglich festlegen. Sie können dies tun, indem Sie die Transaktion mit der [`simulateTransaction`](/docs/de/api-reference/rpc/http/simulatetransaction)-RPC-Methode simulieren.
Es ist eine bewährte Praxis, zuerst mit einem hohen CU-Limit zu simulieren, um sicherzustellen, dass die Simulation selbst erfolgreich ist, und dann den `unitsConsumed` aus der Antwort zu verwenden, um Ihr tatsächliches Limit festzulegen.
```typescript theme={"system"}
import { ComputeBudgetProgram } from "@solana/web3.js";
// Create a test transaction with a high compute limit to ensure simulation succeeds
const testInstructions = [
ComputeBudgetProgram.setComputeUnitLimit({ units: 1_400_000 }),
...instructions, // Your original instructions
];
const testMessage = new TransactionMessage({
payerKey: fromKeypair.publicKey,
recentBlockhash: blockhash,
instructions: testInstructions,
}).compileToV0Message();
const testTransaction = new VersionedTransaction(testMessage);
testTransaction.sign([fromKeypair]);
// Simulate the transaction to get the exact CUs consumed
const { value: simulationResult } = await connection.simulateTransaction(testTransaction);
if (!simulationResult.unitsConsumed) {
throw new Error("Simulation failed to return unitsConsumed");
}
// Add a 10% buffer to the CU estimate
const computeUnitLimit = Math.ceil(simulationResult.unitsConsumed * 1.1);
// Create the instruction to set the CU limit
const setCuLimitInstruction = ComputeBudgetProgram.setComputeUnitLimit({
units: computeUnitLimit,
});
```
Jetzt haben Sie eine Anweisung, die das Berechnungslimit präzise festlegt. Sie werden dies zu Ihrer endgültigen Transaktion hinzufügen.
### 3. Festlegen der richtigen Prioritätsgebühr
Als nächstes bestimmen Sie die optimale Prioritätsgebühr, die Ihrer Transaktion hinzugefügt werden soll. Die Verwendung der Helius [Priority Fee API](/docs/de/priority-fee-api) ist der beste Weg, um eine Echtzeitschätzung basierend auf den aktuellen Netzwerkbedingungen zu erhalten.
Sie müssen die `getPriorityFeeEstimate`-RPC-Methode aufrufen. Für die höchste Einbeziehungschance über die gestakten Verbindungen von Helius verwenden Sie die `recommended: true`-Option.
```typescript theme={"system"}
// The transaction needs to be serialized and base58 encoded
const serializedTransaction = bs58.encode(transaction.serialize());
const response = await fetch("YOUR_RPC_URL", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: "1",
method: "getPriorityFeeEstimate",
params: [
{
// Pass the serialized transaction
transaction: serializedTransaction,
// Use 'recommended' for Helius's staked connections
options: { recommended: true },
},
],
}),
});
const data = await response.json();
if (!data.result || !data.result.priorityFeeEstimate) {
throw new Error("Failed to get priority fee estimate");
}
const priorityFeeEstimate = data.result.priorityFeeEstimate;
// Create the instruction to set the priority fee
const setPriorityFeeInstruction = ComputeBudgetProgram.setComputeUnitPrice({
microLamports: priorityFeeEstimate,
});
```
### 4. Erstellen, Senden und Bestätigen
Stellen Sie nun die endgültige Transaktion mit den neuen Budgetanweisungen für die Berechnung zusammen, senden Sie sie und implementieren Sie einen robusten Polling-Mechanismus, um ihre Bestätigung sicherzustellen.
Verlassen Sie sich nicht auf die Standard-Wiederholungslogik des RPC-Anbieters (`maxRetries` in [`sendTransaction`](/docs/de/api-reference/rpc/http/sendtransaction)). Während die gestakten Verbindungen von Helius Ihre Transaktion direkt an den Leader weiterleiten, kann sie dennoch fallengelassen werden. Sie müssen Ihre eigene Logik zur erneuten Aussendung implementieren, um eine zuverlässige Bestätigung zu gewährleisten.
Ein häufiges Muster ist es, dieselbe Transaktion periodisch erneut zu senden, bis der Blockhash abläuft. **Signieren Sie die Transaktion nur dann erneut, wenn Sie auch einen neuen Blockhash abrufen.** Ein erneutes Signieren mit demselben Blockhash kann dazu führen, dass doppelte Transaktionen bestätigt werden.
```typescript theme={"system"}
// 1. Add the new instructions to your original set
const finalInstructions = [
setCuLimitInstruction,
setPriorityFeeInstruction,
...instructions,
];
// 2. Re-build and re-sign the transaction with the final instructions
const { blockhash: latestBlockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
const finalMessage = new TransactionMessage({
payerKey: fromKeypair.publicKey,
recentBlockhash: latestBlockhash,
instructions: finalInstructions,
}).compileToV0Message();
const finalTransaction = new VersionedTransaction(finalMessage);
finalTransaction.sign([fromKeypair]);
// 3. Send the transaction
const signature = await connection.sendTransaction(finalTransaction, {
skipPreflight: true, // Optional: useful for bypassing client-side checks
});
// 4. Implement a polling loop to confirm the transaction
let confirmed = false;
while (!confirmed) {
const statuses = await connection.getSignatureStatuses([signature]);
const status = statuses && statuses.value && statuses.value[0];
if (status && (status.confirmationStatus === 'confirmed' || status.confirmationStatus === 'finalized')) {
console.log('Transaction confirmed!');
confirmed = true;
}
// Check if the blockhash has expired
const currentBlockHeight = await connection.getBlockHeight();
if (currentBlockHeight > lastValidBlockHeight) {
console.log('Blockhash expired, transaction failed.');
break;
}
// Wait for a short period before polling again
await new Promise(resolve => setTimeout(resolve, 2000));
}
```
Dieses Beispiel bietet eine grundlegende Polling-Schleife. Eine produktionsreife Anwendung erfordert eine ausgefeiltere Logik, einschließlich der Handhabung unterschiedlicher Bestätigungsstatus und möglicher Zeitüberschreitungen.
## Schutz vor Sandwich-Angriffen
Um Ihre Transaktion von Validatoren wegzuleiten, die statistisch mit Sandwich-Angriffen in Verbindung stehen, fügen Sie den `mev-protect=true`-Parameter zu Ihrer RPC-URL hinzu — keine Änderungen an Ihrer Transaktionslogik:
```
https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY&mev-protect=true
```
Sehen Sie, wie MEV Schutz funktioniert, welche Methoden er unterstützt und welche Kompromisse es gibt.
## Verdienen Sie Rabatte auf Ihre Transaktionen
Sie können sich dafür entscheiden, einen Anteil des MEV zu verdienen, den Ihre Transaktionen erzeugen, automatisch in SOL bezahlt — ohne Änderungen an Ihrer Transaktionslogik.
Fügen Sie einen Parameter zu Ihren `sendTransaction`-Aufrufen hinzu, um SOL-Rabatte zu verdienen.
## Verwandte Methoden
Senden Sie eine signierte Transaktion an das Netzwerk
Simulieren Sie eine Transaktion, um Recheneinheiten zu schätzen
Bestätigungsstatus von Transaktionen überprüfen
Abrufen eines aktuellen Blockhashes zur Transaktionssignierung
Aktuelle Blockhöhe für Ablaufprüfungen abrufen