Solana-Überlastung: So sendest du Solana-Transaktionen am besten

Einführung

„Transaktionssimulation fehlgeschlagen: Blockhash nicht gefunden.“ „Transaktion konnte nicht gesendet werden.“ Diese Fehlermeldungen sind nur allzu vertraut. Durch die Netzwerkauslastung werden selbst einfache Transaktionen zum Glücksspiel. Das muss nicht sein.

Dieser Leitfaden zeigt einfache Strategien, mit denen du Zeiten hoher Auslastung effektiv bewältigst und sicherstellst, dass deine Transaktionen verarbeitet werden. Wir behandeln umfassende Ansätze gegen Netzwerküberlastung, darunter Prioritätsgebühren, die Optimierung von Compute Units und einen exklusiven Geheimtipp von Helius, mit dem deine Transaktionen immer durchkommen.

In diesem Leitfaden behandeln wir:

• Serialisierte Transaktionen für Prioritätsgebühren verwenden
• Account-Schlüssel für Prioritätsgebühren verwenden
• Fortgeschrittene Strategien für Prioritätsgebühren
• Techniken zur Transaktionsoptimierung
• Staked Endpoints für eine garantierte Zustellung nutzen

Prioritätsgebühren

Prioritätsgebühren dienen als Gebotsmechanismus. Damit signalisierst du Validatoren, wie wichtig deine Transaktion ist. Diese Gebühren werden in Mikro-Lamports pro Compute Unit angegeben. Ihre Höhe hängt von den jeweiligen Accounts ab, mit denen deine Transaktion interagiert. Dadurch entsteht für jeden Account ein eigener Gebührenmarkt. Wenn du die Gebühren strategisch anhand der Auslastung einzelner Accounts festlegst, erhöhst du deutlich die Chance, dass deine Transaktion in den nächsten Block aufgenommen wird.

Als Nächstes zeigen wir dir verschiedene Ansätze, mit denen du Prioritätsgebühren über die Priority Fee API von Helius korrekt festlegst:

Serialisierte Transaktion

Am einfachsten legst du Prioritätsgebühren mit einer serialisierten Transaktion fest. Eine serialisierte Transaktion ist die binäre Darstellung einer Transaktion. Sie wird in einen Puffer im Wire-Format umgewandelt, der sich über das Netzwerk übertragen lässt.

1. Serialisiere deine Transaktion und übergib sie an die API:

const serializedTx = transaction.serialize();

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: { recommended: true }
    }]
  }),
});

const { result } = await response.json();
const priorityFee = result.priorityFeeEstimate;

2. Füge deiner Transaktion die empfohlene Gebühr hinzu — die Reihenfolge der Instructions spielt keine Rolle:

transaction.add(
  ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  })
);

Account-Schlüssel

Alternativ kannst du der Priority Fee API eine Liste der an der Transaktion beteiligten Account-Schlüssel übergeben:‍

1. Extrahiere die Account-Schlüssel aus deiner Transaktion:

const transaction = new Transaction();

// Add your instructions to the transaction

// Extract all account keys from the transaction
const accountKeys = transaction.compileMessage().accountKeys;

// Convert PublicKeys to base58 strings
const publicKeys = accountKeys.map(key => key.toBase58());

2. Übergib die Account-Schlüssel an die Priority Fee API:

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      accountKeys: publicKeys,
      options: { recommended: true }
    }]
  }),
});

const { result } = await response.json();
const priorityFee = result.priorityFeeEstimate;

3. Füge deiner Transaktion die empfohlene Gebühr hinzu:

transaction.add(
  ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  })
);

Beide Methoden funktionieren, wir empfehlen jedoch serialisierte Transaktionen. Bei Account-Schlüsseln musst du alle relevanten Accounts manuell nachverfolgen und einbeziehen. Fehlt ein Account, kann die Gebührenschätzung ungenau sein. 

Die Methode mit serialisierten Transaktionen schließt dieses Risiko aus. Sie bezieht automatisch alle erforderlichen Accounts ein und liefert anhand des vollständigen Transaktionskontexts genauere Gebührenschätzungen.

Fortgeschrittene Strategien für Prioritätsgebühren

Für die meisten Szenarien reicht eine serialisierte Transaktion mit der empfohlenen Prioritätsgebühr aus. Wenn du mehr Kontrolle brauchst, kannst du über die Priority Fee API Schätzungen für verschiedene Prioritätsstufen anfordern und die Auswertung leerer Slots aktivieren.

Prioritätsstufen

Dieses Beispiel zeigt, wie du alle Prioritätsgebührenstufen anforderst:

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: {
        includeAllPriorityFeeLevels: true
      }
    }]
  }),
});

const { result } = await response.json();
console.log(result.priorityFeeLevels);

Dadurch wird ein Objekt mit verschiedenen Prioritätsstufen zurückgegeben:

{
  "priorityFeeLevels": {
    "min": 10000.0,
    "low": 10000.0,
    "medium": 10000.0,
    "high": 100000.0,
    "veryHigh": 5483924.800000011,
    "unsafeMax": 8698904817.0
  }
}

Die Prioritätsstufen entsprechen verschiedenen Perzentilen der letzten Transaktionsgebühren:

• min: 0. Perzentil
• low: 25. Perzentil
• medium: 50. Perzentil
• high: 75. Perzentil
• veryHigh: 95. Perzentil
• unsafeMax: 100. Perzentil (mit Vorsicht verwenden)

Um die Erfolgsquote deiner Transaktionen weiter zu verbessern, solltest du die Prioritätsstufe high oder very high verwenden. Sei bei höheren Prioritätsstufen jedoch vorsichtig. Besonders veryHigh und unsafeMax können die Transaktionskosten deutlich erhöhen.‍

Auswertung leerer Slots

Ein aktuelles Update der Priority Fee API ermöglicht intelligentere Gebührenschätzungen, indem leere Slots berücksichtigt werden. Wenn Blöcke keine Transaktionen für einen bestimmten Account enthalten, kannst du die API so konfigurieren, dass sie diese Slots mit Gebühren von null bewertet. Das liefert bei geringer Netzwerkaktivität genauere Schätzungen:

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: {
        recommended: true,
        evaluateEmptySlotAsZero: true
      }
    }]
  }),
});

Wenn evaluateEmptySlotAsZero aktiviert ist, führt die API folgende Schritte aus:

• Sie identifiziert Blöcke ohne Transaktionen für deine Accounts
• Sie zählt diese leeren Slots mit Gebühren von null
• Sie korrigiert Schätzungen bei geringer Auslastung nach unten
• Sie verhindert, dass du bei geringer Netzwerkaktivität zu viel zahlst

Strategien zur Transaktionsoptimierung

Neben Prioritätsgebühren umfasst die Transaktionsoptimierung mehrere wichtige Komponenten, die gemeinsam die Erfolgsquote verbessern:

Verwaltung von Compute Units

1. Nutze das Helius SDK, um die optimalen Compute Units für deine Transaktion zu ermitteln:‍

const response = await helius.rpc.getComputeUnits({
  transaction: serializedTransaction
});

const computeUnits = response.computeUnits;

2. Füge deiner Transaktion ein Compute-Unit-Limit hinzu:

transaction.add(
  ComputeBudgetProgram.setComputeUnitLimit({
    units: computeUnits
  })
);

Commitment-Level

‍Für die meisten Anwendungen bietet das Commitment-Level processed die beste Balance. Es:

• Bietet die schnellste Bestätigungszeit
• Bietet für die meisten Anwendungsfälle ausreichend Sicherheit
• Verringert das Risiko, dass der Blockhash abläuft
• Minimiert verworfene Transaktionen bei hoher Auslastung

Verwende zum Senden und Bestätigen von Transaktionen immer dasselbe Commitment-Level. So verhält sich deine Anwendung konsistent.

RPC-Konfiguration

Setze maxRetries auf 0 und implementiere deine eigene Wiederholungslogik, um erneut gesendete Transaktionen besser zu kontrollieren. Verwende skipPreflight: true, um die Latenz zu verringern. Das ist besonders bei hoher Auslastung nützlich:

const signature = await connection.sendTransaction(transaction, {
  maxRetries: 0,
  skipPreflight: true
});

Einen Staked Endpoint verwenden

Der Staked Endpoint von Helius bietet direkten, garantierten Zugriff auf gestakte Verbindungen. Dadurch musst du Prioritätsgebühren nicht mehr manuell optimieren:

const connection = new Connection(
  'https://staked.helius-rpc.com?api-key=YOUR_API_KEY'
);

// Transaction will be processed with optimal priority
const signature = await connection.sendTransaction(transaction);

Der Staked Endpoint:

• Garantiert gestakte Bandbreite
• Reduziert Transaktionsfehler bei hoher Auslastung
• Beschleunigt die Weiterleitung von Transaktionen über dedizierte Infrastruktur

Fazit

Prioritätsgebühren effektiv einzusetzen ist entscheidend, damit Transaktionen auf Solana erfolgreich verarbeitet werden — besonders bei hoher Netzwerkauslastung. Mit der Helius Priority Fee API und den hier beschriebenen Strategien kannst du die Erfolgsquote deutlich verbessern und zugleich die Kosten im Blick behalten. Beobachte die Netzwerkbedingungen und passe deine Strategie an, um optimale Ergebnisse zu erzielen.

Wenn du bis hierher gelesen hast: Vielen Dank! Wir hoffen, dieser Leitfaden hat dir gezeigt, wie du deine Transaktionen auf Solana optimierst. Abonniere unseren Newsletter, damit du keine Neuigkeiten zu Solana verpasst. 

Möchtest du tiefer einsteigen?

Entdecke noch heute die neuesten Artikel im Helius-Blog und setze deine Reise mit Solana fort.