Schätzung der Solana-Prioritätsgebühr: Methode mit serialisierter Transaktion

Genaueste Methode: Erhalte Schätzungen der Prioritätsgebühr mit höchster Präzision, indem du deine exakte Transaktion analysierst. Empfohlen für Produktionsanwendungen, bei denen Genauigkeit besonders wichtig ist.

Überblick

Serialisierte Transaktionen liefern die genauesten Gebührenschätzungen, da die API exakt analysieren kann, welche Konten und Vorgänge in deiner Transaktion verwendet werden.

Why Use Serialized Transactions

Höchste Genauigkeit – Analysiert die exakten Vorgänge
Detaillierte Analyse – Anweisungsspezifische Muster
Realistische Schätzungen – Bildet die tatsächliche Transaktion ab
Produktionsbereit – Für kritische Anwendungen entwickelt

Best For

Produktionsanwendungen
Komplexe Transaktionen
Kritische Vorgänge
Wenn maximale Genauigkeit erforderlich ist

Vorteile gegenüber Kontoschlüsseln

Accuracy Benefits
Real-World Benefits

Instruction-Specific Analysis

Die API kann bestimmte Vorgänge und deren historische Gebührenmuster analysieren, nicht nur die Kontoaktivität.

Transaction Size Awareness

Berücksichtigt die tatsächliche Größe und Komplexität deiner Transaktion, um genauere Schätzungen zu liefern.

Read-Only Account Handling

Analysiert sowohl beschreibbare als auch schreibgeschützte Konten im Kontext ihrer Transaktion besser.

Implementierungsleitfaden

Build Your Transaction

Erstelle deine Transaktion mit allen Anweisungen außer der Prioritätsgebühr

Serialize the Transaction

Konvertiere deine Transaktion in ein serialisiertes Format

Get Fee Estimate

Rufe die Priority Fee API mit deiner serialisierten Transaktion auf

Apply Priority Fee

Füge die Anweisung für die Prioritätsgebühr hinzu und sende deine Transaktion

Schnellstartbeispiel

import { 
  Connection, 
  PublicKey, 
  Transaction, 
  SystemProgram, 
  ComputeBudgetProgram 
} from "@solana/web3.js";
import bs58 from "bs58";

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

// 1. Build your transaction (without priority fee)
const transaction = new Transaction();
const transferIx = SystemProgram.transfer({
  fromPubkey: senderKeypair.publicKey,
  toPubkey: recipientPublicKey,
  lamports: 1000000, // 0.001 SOL
});
transaction.add(transferIx);

// 2. Set required fields and serialize
transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.feePayer = senderKeypair.publicKey;
const serializedTx = bs58.encode(transaction.serialize());

// 3. Get priority fee estimate
const priorityFee = await getPriorityFeeEstimate(connection, serializedTx, "Medium");

// 4. Add priority fee and send
transaction.instructions = []; // Reset
transaction.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }));
transaction.add(transferIx);
transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.sign(senderKeypair);

import requests
import json
from solana.transaction import Transaction
from solana.system_program import transfer, TransferParams

# Build and serialize transaction
def get_serialized_transaction():
    # Build your transaction here
    # Return base58 encoded serialized transaction
    pass

# Get priority fee estimate
def get_priority_fee_estimate(serialized_tx, priority_level="Medium"):
    response = requests.post(
        "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY",
        json={
            "jsonrpc": "2.0",
            "id": "1",
            "method": "getPriorityFeeEstimate",
            "params": [{
                "transaction": serialized_tx,
                "options": {
                    "priorityLevel": priority_level,
                    "recommended": True
                }
            }]
        }
    )
    return response.json()["result"]["priorityFeeEstimate"]

# Usage
serialized_tx = get_serialized_transaction()
fee = get_priority_fee_estimate(serialized_tx, "High")
print(f"Priority fee: {fee} micro-lamports")

Zentrale Implementierungsfunktion

Hier ist eine wiederverwendbare Funktion, mit der du Schätzungen der Prioritätsgebühr aus serialisierten Transaktionen abrufen kannst:

async function getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel = "Medium") {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTransaction,
        options: { 
          priorityLevel: priorityLevel,
          recommended: true 
        }
      }]
    })
  });
  
  const result = await response.json();
  
  if (result.error) {
    throw new Error(`Fee estimation failed: ${JSON.stringify(result.error)}`);
  }
  
  return result.result.priorityFeeEstimate;
}

Vollständige Implementierungsbeispiele

Simple Transfer
Token Transfer
Complex Multi-Instruction

Expand to see complete example

const { 
  Connection, 
  PublicKey, 
  Transaction, 
  SystemProgram, 
  ComputeBudgetProgram, 
  sendAndConfirmTransaction,
  Keypair
} = require("@solana/web3.js");
const bs58 = require("bs58");

// Initialize connection and accounts
const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY");
const senderKeypair = Keypair.fromSecretKey(bs58.decode("YOUR_PRIVATE_KEY"));
const receiverPublicKey = new PublicKey("RECIPIENT_PUBLIC_KEY");

async function sendTransactionWithPriorityFee(amount, priorityLevel = "Medium") {
  // 1. Create transaction with transfer instruction
  const transaction = new Transaction();
  const transferIx = SystemProgram.transfer({
    fromPubkey: senderKeypair.publicKey,
    toPubkey: receiverPublicKey,
    lamports: amount,
  });
  transaction.add(transferIx);
  
  // 2. Set required fields for serialization
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.feePayer = senderKeypair.publicKey;
  
  // 3. Serialize the transaction
  const serializedTransaction = bs58.encode(transaction.serialize());
  
  // 4. Get priority fee estimate
  const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
  console.log(`Estimated ${priorityLevel} priority fee: ${priorityFee} micro-lamports`);
  
  // 5. Reset transaction and add priority fee instruction first
  transaction.instructions = [];
  
  // Add priority fee instruction
  const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  });
  transaction.add(priorityFeeIx);
  
  // Re-add the original transfer instruction
  transaction.add(transferIx);
  
  // 6. Update blockhash and sign
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.sign(senderKeypair);
  
  // 7. Send the transaction
  try {
    const signature = await sendAndConfirmTransaction(
      connection,
      transaction,
      [senderKeypair],
      { maxRetries: 0 } // Set to 0 for staked connection usage
    );
    console.log(`Transaction successful with signature: ${signature}`);
    return signature;
  } catch (error) {
    console.error("Error sending transaction:", error);
    throw error;
  }
}

// Usage
sendTransactionWithPriorityFee(1000000, "High"); // Send 0.001 SOL with high priority

Expand to see complete example

const { 
  Connection, 
  PublicKey, 
  Transaction, 
  ComputeBudgetProgram,
  sendAndConfirmTransaction,
  Keypair
} = require("@solana/web3.js");
const { 
  createTransferInstruction,
  getAssociatedTokenAddress,
  TOKEN_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID
} = require("@solana/spl-token");
const bs58 = require("bs58");

async function sendTokenWithPriorityFee(
  connection,
  senderKeypair,
  recipientPublicKey,
  mintAddress,
  amount,
  priorityLevel = "Medium"
) {
  // 1. Get token account addresses
  const senderTokenAccount = await getAssociatedTokenAddress(
    mintAddress,
    senderKeypair.publicKey
  );
  
  const recipientTokenAccount = await getAssociatedTokenAddress(
    mintAddress,
    recipientPublicKey
  );
  
  // 2. Create transaction with token transfer instruction
  const transaction = new Transaction();
  const transferIx = createTransferInstruction(
    senderTokenAccount,
    recipientTokenAccount,
    senderKeypair.publicKey,
    amount,
    [],
    TOKEN_PROGRAM_ID
  );
  transaction.add(transferIx);
  
  // 3. Set required fields and serialize
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.feePayer = senderKeypair.publicKey;
  const serializedTransaction = bs58.encode(transaction.serialize());
  
  // 4. Get priority fee estimate
  const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
  console.log(`Token transfer priority fee: ${priorityFee} micro-lamports`);
  
  // 5. Reset and rebuild transaction with priority fee
  transaction.instructions = [];
  
  // Add priority fee instruction first
  const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  });
  transaction.add(priorityFeeIx);
  
  // Re-add the transfer instruction
  transaction.add(transferIx);
  
  // 6. Update blockhash and send
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.sign(senderKeypair);
  
  const signature = await sendAndConfirmTransaction(
    connection,
    transaction,
    [senderKeypair],
    { maxRetries: 0 }
  );
  
  return signature;
}

Expand to see complete example

async function complexTransactionWithPriorityFee(connection, keypair) {
  // 1. Build complex transaction with multiple instructions
  const transaction = new Transaction();
  
  // Add multiple instructions
  const createAccountIx = SystemProgram.createAccount({
    fromPubkey: keypair.publicKey,
    newAccountPubkey: newAccountKeypair.publicKey,
    lamports: await connection.getMinimumBalanceForRentExemption(165),
    space: 165,
    programId: TOKEN_PROGRAM_ID,
  });
  
  const initializeAccountIx = createInitializeAccountInstruction(
    newAccountKeypair.publicKey,
    mintAddress,
    keypair.publicKey,
    TOKEN_PROGRAM_ID
  );
  
  const transferIx = SystemProgram.transfer({
    fromPubkey: keypair.publicKey,
    toPubkey: recipientPublicKey,
    lamports: 1000000,
  });
  
  transaction.add(createAccountIx);
  transaction.add(initializeAccountIx);
  transaction.add(transferIx);
  
  // 2. Set required fields and serialize
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.feePayer = keypair.publicKey;
  const serializedTransaction = bs58.encode(transaction.serialize());
  
  // 3. Get priority fee estimate for complex transaction
  const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, "High");
  console.log(`Complex transaction priority fee: ${priorityFee} micro-lamports`);
  
  // 4. Rebuild transaction with priority fee
  transaction.instructions = [];
  
  // Add priority fee instruction first
  const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  });
  transaction.add(priorityFeeIx);
  
  // Optional: Set compute unit limit for complex transactions
  const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({
    units: 400000 // Adjust based on your transaction complexity
  });
  transaction.add(computeLimitIx);
  
  // Re-add all original instructions
  transaction.add(createAccountIx);
  transaction.add(initializeAccountIx);
  transaction.add(transferIx);
  
  // 5. Update blockhash and send
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.sign(keypair, newAccountKeypair);
  
  const signature = await sendAndConfirmTransaction(
    connection,
    transaction,
    [keypair, newAccountKeypair],
    { maxRetries: 0 }
  );
  
  return signature;
}

Erweiterte Konfigurationsoptionen

Include All Priority Levels

Rufe Schätzungen für alle Prioritätsstufen gleichzeitig ab:

async function getAllPriorityLevels(connection, serializedTransaction) {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTransaction,
        options: { 
          includeAllPriorityFeeLevels: true
        }
      }]
    })
  });
  
  const result = await response.json();
  return result.result.priorityFeeLevels;
}

// Usage
const allLevels = await getAllPriorityLevels(connection, serializedTransaction);
console.log("All priority levels:", allLevels);
/*
Output:
{
  "min": 0,
  "low": 1000, 
  "medium": 5000,
  "high": 15000,
  "veryHigh": 50000,
  "unsafeMax": 100000
}
*/

Include Detailed Analysis

Fordere detaillierte Informationen zur Gebührenberechnung an:

async function getDetailedFeeAnalysis(connection, serializedTransaction) {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTransaction,
        options: { 
          includeDetails: true,
          priorityLevel: "Medium"
        }
      }]
    })
  });
  
  const result = await response.json();
  console.log("Detailed analysis:", result.result);
  return result.result;
}

So erhältst du Einblicke in die Berechnung der Gebühr, einschließlich einer Analyse pro Konto.

Custom Lookback Period

Passe die Anzahl der analysierten slots an:

async function getCustomLookbackEstimate(connection, serializedTransaction, lookbackSlots = 50) {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTransaction,
        options: { 
          priorityLevel: "Medium",
          lookbackSlots: lookbackSlots  // 1-150, default is 150
        }
      }]
    })
  });
  
  const result = await response.json();
  return result.result.priorityFeeEstimate;
}

// Compare different lookback periods
const recentEstimate = await getCustomLookbackEstimate(connection, serializedTx, 30);
const longerEstimate = await getCustomLookbackEstimate(connection, serializedTx, 100);

console.log(`Recent (30 slots): ${recentEstimate} micro-lamports`);
console.log(`Longer (100 slots): ${longerEstimate} micro-lamports`);

Best Practices

Transaction Serialization

Serialisiere immer deine tatsächliche Transaktion, nicht eine vereinfachte Version

// ✅ Good - serialize actual transaction
const transaction = new Transaction();
transaction.add(actualInstruction1);
transaction.add(actualInstruction2);
const serialized = bs58.encode(transaction.serialize());

Instruction Order

Füge alle Anweisungen außer der Prioritätsgebühr ein in deine Transaktion für die Schätzung

// ✅ Good - all business logic included
transaction.add(createAccountIx);
transaction.add(initializeIx);
transaction.add(transferIx);

// ❌ Don't include priority fee in estimation

Strategien zur Fehlerbehandlung

Robust Error Handling
Simple Error Handling

class SerializedTransactionFeeEstimator {
  constructor(connection) {
    this.connection = connection;
    this.fallbackFee = 10000; // 10k micro-lamports
  }

  async getEstimate(serializedTransaction, priorityLevel = "Medium") {
    try {
      // Primary attempt with serialized transaction
      return await this.getPrimaryEstimate(serializedTransaction, priorityLevel);
    } catch (error) {
      console.warn("Serialized transaction estimate failed:", error.message);
      
      // Fallback to account-based estimation
      try {
        return await this.getFallbackEstimate(serializedTransaction, priorityLevel);
      } catch (fallbackError) {
        console.warn("Fallback estimate failed:", fallbackError.message);
        return this.getFallbackFee(priorityLevel);
      }
    }
  }

  async getPrimaryEstimate(serializedTransaction, priorityLevel) {
    const response = await fetch(this.connection.rpcEndpoint, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: "1",
        method: "getPriorityFeeEstimate",
        params: [{
          transaction: serializedTransaction,
          options: { 
            priorityLevel: priorityLevel,
            recommended: true 
          }
        }]
      })
    });

    const result = await response.json();
    if (result.error) {
      throw new Error(result.error.message);
    }
    
    return result.result.priorityFeeEstimate;
  }

  async getFallbackEstimate(serializedTransaction, priorityLevel) {
    // Extract account keys from transaction and use account-based estimation
    const transaction = Transaction.from(bs58.decode(serializedTransaction));
    const accountKeys = transaction.instructions
      .flatMap(ix => [ix.programId, ...ix.keys.map(k => k.pubkey)])
      .map(key => key.toString());

    const uniqueAccountKeys = [...new Set(accountKeys)];
    
    // Use account-based estimation as fallback
    const response = await fetch(this.connection.rpcEndpoint, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: "1",
        method: "getPriorityFeeEstimate",
        params: [{
          accountKeys: uniqueAccountKeys,
          options: { 
            priorityLevel: priorityLevel,
            recommended: true 
          }
        }]
      })
    });

    const result = await response.json();
    if (result.error) {
      throw new Error(result.error.message);
    }
    
    return result.result.priorityFeeEstimate;
  }

  getFallbackFee(priorityLevel) {
    const fallbacks = {
      "Low": 1000,
      "Medium": 5000,
      "High": 15000,
      "VeryHigh": 50000
    };
    
    return fallbacks[priorityLevel] || 5000;
  }
}

// Usage
const estimator = new SerializedTransactionFeeEstimator(connection);
const fee = await estimator.getEstimate(serializedTransaction, "High");

async function safeGetPriorityFeeEstimate(connection, serializedTransaction, priorityLevel = "Medium") {
  try {
    return await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
  } catch (error) {
    console.warn(`Priority fee estimation failed: ${error.message}`);
    
    // Extract account keys and fall back to account-based estimation
    try {
      const transaction = Transaction.from(bs58.decode(serializedTransaction));
      const accountKeys = transaction.instructions
        .flatMap(ix => [ix.programId, ...ix.keys.map(k => k.pubkey)])
        .map(key => key.toString());
      
      const uniqueAccountKeys = [...new Set(accountKeys)];
      return await getAccountBasedEstimate(connection, uniqueAccountKeys, priorityLevel);
    } catch (fallbackError) {
      console.warn(`Fallback estimation failed: ${fallbackError.message}`);
      
      // Return reasonable fallback based on priority level
      const fallbacks = {
        "Low": 1000,
        "Medium": 5000,
        "High": 15000,
        "VeryHigh": 50000
      };
      
      return fallbacks[priorityLevel] || 5000;
    }
  }
}

Häufige Probleme und Lösungen

Transaction Serialization Errors

Problem: Fehler beim Serialisieren unvollständiger TransaktionenLösung: Lege vor der Serialisierung immer die erforderlichen Felder fest:

// ✅ Always set these fields
transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.feePayer = keypair.publicKey;

// Then serialize
const serialized = bs58.encode(transaction.serialize());

Stale Blockhash Issues

Problem: Ein veralteter Blockhash führt zu fehlgeschlagenen TransaktionenLösung: Rufe vor dem endgültigen Senden immer einen aktuellen Blockhash ab:

// Get estimate with temporary blockhash
const tempBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.recentBlockhash = tempBlockhash;
const serialized = bs58.encode(transaction.serialize());

const priorityFee = await getPriorityFeeEstimate(connection, serialized, "Medium");

// Reset and rebuild with fresh blockhash
transaction.instructions = [];
transaction.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }));
transaction.add(originalInstruction);

// Get FRESH blockhash before sending
const freshBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.recentBlockhash = freshBlockhash;

Large Transaction Errors

Problem: Die Transaktion ist zu groß für die SerialisierungLösung: Verwende versionierte Transaktionen oder teile den Vorgang in mehrere Transaktionen auf:

import { VersionedTransaction, TransactionMessage } from "@solana/web3.js";

// For large transactions, use versioned transactions
const messageV0 = new TransactionMessage({
  payerKey: keypair.publicKey,
  recentBlockhash: (await connection.getLatestBlockhash()).blockhash,
  instructions: [instruction1, instruction2, instruction3] // Many instructions
}).compileToV0Message();

const versionedTransaction = new VersionedTransaction(messageV0);
const serialized = bs58.encode(versionedTransaction.serialize());

Wann du serialisierte Transaktionen statt Kontoschlüsseln verwenden solltest

Use Serialized Transactions

Produktionsanwendungen

Maximale Genauigkeit erforderlich
Komplexe Transaktionen mit mehreren Anweisungen
Kritische Vorgänge
Leistungssensible Anwendungen

Entwicklungsszenarien

Abschließende Integrationstests
Leistungsoptimierung
deployment in der Produktion

Use Account Keys

Entwicklung und Prototyping

Schnelle Schätzungen während der Entwicklung
Einfache Transaktionen
Planung vor der Transaktion
Architekturbeschränkungen, die eine Serialisierung verhindern

Analyseszenarien

Analyse von Gebührenmustern auf Kontoebene
Gebündelte Kontoanalyse
Schnelle Marktrecherche

Weiterführende Ressourcen

Account Keys Method

Erweiterte Methode mit Kontoschlüsseln für spezielle Anwendungsfälle

API Reference

Vollständige API-Dokumentation und Parameter

Erste Schritte

Streaming von Daten und Event-Überwachung

Daten-APIs und RPCs

Trading

Transaktionen senden

Wallet-as-a-Service

Datenschutz

Ressourcen

Schätzung der Solana-Prioritätsgebühr: Methode mit serialisierter Transaktion

Überblick

Why Use Serialized Transactions

Best For

Vorteile gegenüber Kontoschlüsseln

Instruction-Specific Analysis

Transaction Size Awareness

Read-Only Account Handling

DeFi-Handel

NFT-Minting

Transaktionen mit mehreren Anweisungen

Programminteraktionen

Implementierungsleitfaden

Schnellstartbeispiel

Zentrale Implementierungsfunktion

Vollständige Implementierungsbeispiele

Erweiterte Konfigurationsoptionen

Best Practices

Transaction Serialization

Instruction Order

Strategien zur Fehlerbehandlung

Häufige Probleme und Lösungen

Wann du serialisierte Transaktionen statt Kontoschlüsseln verwenden solltest

Use Serialized Transactions

Use Account Keys

Weiterführende Ressourcen

Account Keys Method

API Reference

​Überblick

Why Use Serialized Transactions

Best For

​Vorteile gegenüber Kontoschlüsseln

Instruction-Specific Analysis

Transaction Size Awareness

Read-Only Account Handling

​DeFi-Handel

​NFT-Minting

​Transaktionen mit mehreren Anweisungen

​Programminteraktionen

​Implementierungsleitfaden

​Schnellstartbeispiel

​Zentrale Implementierungsfunktion

​Vollständige Implementierungsbeispiele

​Erweiterte Konfigurationsoptionen

​Best Practices

Transaction Serialization

Instruction Order

​Strategien zur Fehlerbehandlung

​Häufige Probleme und Lösungen

​Wann du serialisierte Transaktionen statt Kontoschlüsseln verwenden solltest

Use Serialized Transactions

Use Account Keys

​Weiterführende Ressourcen

Account Keys Method

API Reference

Überblick

Vorteile gegenüber Kontoschlüsseln

DeFi-Handel

NFT-Minting

Transaktionen mit mehreren Anweisungen

Programminteraktionen

Implementierungsleitfaden

Schnellstartbeispiel

Zentrale Implementierungsfunktion

Vollständige Implementierungsbeispiele

Erweiterte Konfigurationsoptionen

Best Practices

Strategien zur Fehlerbehandlung

Häufige Probleme und Lösungen

Wann du serialisierte Transaktionen statt Kontoschlüsseln verwenden solltest

Weiterführende Ressourcen