Solana-RPC optimieren: Best Practices für Performance und Kosten

Durch die Optimierung der RPC-Nutzung kannst du die Performance deutlich steigern, Kosten senken und die Benutzererfahrung verbessern. Dieser Leitfaden beschreibt bewährte Techniken für effiziente Interaktionen mit Solana RPC.

Schnellstart

Transaction Optimization

Optimiere Compute Units, Priority Fees und das Senden von Transaktionen

Data Retrieval

Effiziente Muster zum Abrufen von Account- und Programmdaten

Real-time Monitoring

Optimiere WebSocket-Abonnements und Streaming-Daten

Best Practices

Richtlinien für Performance und Ressourcenverwaltung

Transaktionsoptimierung

Compute Units verwalten

1. Simuliere die Transaktion, um die tatsächliche Nutzung zu ermitteln:

const testTransaction = new VersionedTransaction(/* your transaction */);
const simulation = await connection.simulateTransaction(testTransaction, {
  replaceRecentBlockhash: true,
  sigVerify: false
});
const unitsConsumed = simulation.value.unitsConsumed;

2. Lege passende Limits mit Puffer fest:

const computeUnitLimit = Math.ceil(unitsConsumed * 1.1);
const computeUnitIx = ComputeBudgetProgram.setComputeUnitLimit({ 
  units: computeUnitLimit 
});
instructions.unshift(computeUnitIx); // Add at beginning

Priority Fees optimieren

1. Rufe dynamische Gebührenschätzungen ab:

const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    method: 'getPriorityFeeEstimate',
    params: [{
      accountKeys: ['11111111111111111111111111111112'], // System Program
      options: { recommended: true }
    }]
  })
});
const { priorityFeeEstimate } = await response.json().result;

2. Wende die Priority Fee an:

const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({ 
  microLamports: priorityFeeEstimate 
});
instructions.unshift(priorityFeeIx);

Best Practices zum Senden von Transaktionen

Standard Approach
With Confirmation

// Serialize and encode
const serializedTx = transaction.serialize();
const signature = await connection.sendRawTransaction(serializedTx, {
  skipPreflight: true, // Saves ~100ms
  maxRetries: 0 // Handle retries manually
});

// Send and confirm with custom logic
const signature = await connection.sendRawTransaction(serializedTx);

// Monitor confirmation
const confirmation = await connection.confirmTransaction({
  signature,
  blockhash: latestBlockhash.blockhash,
  lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
});

Datenabruf optimieren

Erweiterte Paginierungsmethoden (V2)

Verwende für umfangreiche Datenabfragen die neuen V2-Methoden mit cursorbasierter Paginierung:

⚡ Performance Boost

getProgramAccountsV2 und getTokenAccountsByOwnerV2 verbessern die Performance von Anwendungen, die große Datensätze verarbeiten, erheblich:

Konfigurierbare Limits: 1–10.000 Accounts pro request
Cursorbasierte Paginierung: Verhindert Timeouts bei großen Abfragen
Inkrementelle Aktualisierungen: Verwende changedSinceSlot für die Echtzeitsynchronisierung
Effizientere Speichernutzung: Streame Daten, statt alles auf einmal zu laden

Beispiel: Effiziente Abfrage von Programm-Accounts

// ❌ Old approach - could timeout with large datasets
const allAccounts = await connection.getProgramAccounts(programId, {
  encoding: 'base64',
  filters: [{ dataSize: 165 }]
});

// ✅ New approach - paginated with better performance
let allAccounts = [];
let paginationKey = null;

do {
  const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: '1',
      method: 'getProgramAccountsV2',
      params: [
        programId,
        {
          encoding: 'base64',
          filters: [{ dataSize: 165 }],
          limit: 5000,
          ...(paginationKey && { paginationKey })
        }
      ]
    })
  });
  
  const data = await response.json();
  allAccounts.push(...data.result.accounts);
  paginationKey = data.result.paginationKey;
} while (paginationKey);

Inkrementelle Aktualisierungen für Echtzeitanwendungen:

// Get only accounts modified since a specific slot
const incrementalUpdate = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: '1',
    method: 'getProgramAccountsV2',
    params: [
      programId,
      {
        encoding: 'jsonParsed',
        limit: 1000,
        changedSinceSlot: lastProcessedSlot // Only get recent changes
      }
    ]
  })
});

Datenabruf optimieren

Effiziente Account-Abfragen

Single Account
Multiple Accounts
Program Accounts

// Use dataSlice to reduce payload size
const accountInfo = await connection.getAccountInfo(pubkey, {
  encoding: 'base64',
  dataSlice: { offset: 0, length: 100 }, // Only get needed data
  commitment: 'confirmed'
});

// Batch multiple account queries
const accounts = await connection.getMultipleAccountsInfo([
  pubkey1, pubkey2, pubkey3
], {
  encoding: 'base64',
  commitment: 'confirmed'
});

// Use filters to reduce data transfer
const accounts = await connection.getProgramAccounts(programId, {
  filters: [
    { dataSize: 165 }, // Token account size
    { memcmp: { offset: 0, bytes: mintAddress }}
  ],
  encoding: 'jsonParsed'
});

Token-Guthaben abfragen

// Don't do this - requires N+1 RPC calls
const tokenAccounts = await connection.getTokenAccountsByOwner(owner, {
  programId: TOKEN_PROGRAM_ID
});
const balances = await Promise.all(
  tokenAccounts.value.map(acc => 
    connection.getTokenAccountBalance(acc.pubkey)
  )
);
// ~500ms + (100ms * N accounts)

// Single call with parsed data
const tokenAccounts = await connection.getTokenAccountsByOwner(owner, {
  programId: TOKEN_PROGRAM_ID
}, { encoding: 'jsonParsed' });

const balances = tokenAccounts.value.map(acc => ({
  mint: acc.account.data.parsed.info.mint,
  amount: acc.account.data.parsed.info.tokenAmount.uiAmount
}));
// ~500ms total - 95% reduction for large wallets

Transaktionsverlauf

Verwende für den vollständigen Verlauf einer Adresse getTransactionsForAddress. Diese exklusive Helius-Methode gibt mit einem einzigen Aufruf vollständige Transaktionsdaten zurück, einschließlich der Aktivitäten zugehöriger Token-Accounts:

// Avoid sequential transaction fetching
const signatures = await connection.getSignaturesForAddress(address, { limit: 100 });
const transactions = await Promise.all(
  signatures.map(sig => connection.getTransaction(sig.signature))
);
// ~1s + (200ms * 100 txs) = ~21s
// Also note: getSignaturesForAddress doesn't include token account transactions

// Use getTransactionsForAddress for full history including token accounts
const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getTransactionsForAddress',
    params: [
      address,
      {
        transactionDetails: 'full',
        limit: 100,
        filters: { tokenAccounts: 'balanceChanged' }
      }
    ]
  })
});
// ~100ms total - includes complete token history in one call

Übertragungsverlauf

Wenn du nur Bewegungen von Token oder SOL benötigst – etwa für Zahlungen, Portfolioaktivitäten oder den Kontenabgleich –, verwende getTransfersByAddress. Diese exklusive Helius-Methode erfordert mindestens einen Developer-Tarif. Sie gibt geparste, lesbare Übertragungsobjekte zurück, in denen Eigentümer, Mints, Beträge und Dezimalstellen bereits aufgelöst sind. Dadurch entfällt das Parsen von Transaktionen vollständig:

// Parsed USDC transfers received by a wallet - no manual parsing needed
const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getTransfersByAddress',
    params: [
      address, // Wallet owner address, not a token account
      {
        mint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
        direction: 'in',
        limit: 100
      }
    ]
  })
});
// Each transfer includes parsed sender, recipient, amount, decimals, and uiAmount

Faustregel: Verwende getTransactionsForAddress, wenn du vollständige Transaktions-Payloads oder Aktivitäten ohne Übertragungen benötigst. Verwende getTransfersByAddress, wenn du übersichtliche Übertragungsdatensätze für Hauptbücher und die Zahlungsverfolgung benötigst.

Echtzeitüberwachung

Account-Abonnements

// Avoid polling - wastes resources
setInterval(async () => {
  const accountInfo = await connection.getAccountInfo(pubkey);
  // Process updates...
}, 1000);

// Use WebSocket subscriptions for real-time updates
const subscriptionId = connection.onAccountChange(
  pubkey,
  (accountInfo, context) => {
    // Handle real-time updates
    console.log('Account updated:', accountInfo);
  },
  'confirmed',
  { encoding: 'base64', dataSlice: { offset: 0, length: 100 }}
);

Programm-Accounts überwachen

// Monitor specific program accounts with filters
connection.onProgramAccountChange(
  programId,
  (accountInfo, context) => {
    // Handle program account changes
  },
  'confirmed',
  {
    filters: [
      { dataSize: 1024 },
      { memcmp: { offset: 0, bytes: ACCOUNT_DISCRIMINATOR }}
    ],
    encoding: 'base64'
  }
);

Transaktionen überwachen

// Subscribe to transaction logs for real-time monitoring
const ws = new WebSocket(`wss://mainnet.helius-rpc.com/?api-key=${API_KEY}`);

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'logsSubscribe',
    params: [
      { mentions: [programId] },
      { commitment: 'confirmed' }
    ]
  }));
});

ws.on('message', (data) => {
  const message = JSON.parse(data);
  if (message.params) {
    const signature = message.params.result.value.signature;
    // Process transaction signature
  }
});

Fortgeschrittene Muster

Intelligente Wiederholungslogik

class RetryManager {
  private backoff = new ExponentialBackoff({
    min: 100,
    max: 5000,
    factor: 2,
    jitter: 0.2
  });

  async executeWithRetry<T>(operation: () => Promise<T>): Promise<T> {
    while (true) {
      try {
        return await operation();
      } catch (error) {
        if (error.message.includes('429')) {
          // Rate limit - wait and retry
          await this.backoff.delay();
          continue;
        }
        throw error;
      }
    }
  }
}

Speichereffiziente Verarbeitung

// Process large datasets in chunks
function chunk<T>(array: T[], size: number): T[][] {
  return Array.from({ length: Math.ceil(array.length / size) }, (_, i) =>
    array.slice(i * size, i * size + size)
  );
}

// Process program accounts in batches
const allAccounts = await connection.getProgramAccounts(programId, {
  dataSlice: { offset: 0, length: 32 }
});

const chunks = chunk(allAccounts, 100);
for (const batch of chunks) {
  const detailedAccounts = await connection.getMultipleAccountsInfo(
    batch.map(acc => acc.pubkey)
  );
  // Process batch...
}

Connection-Pooling

class ConnectionPool {
  private connections: Connection[] = [];
  private currentIndex = 0;

  constructor(rpcUrls: string[]) {
    this.connections = rpcUrls.map(url => new Connection(url));
  }

  getConnection(): Connection {
    const connection = this.connections[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.connections.length;
    return connection;
  }
}

const pool = new ConnectionPool([
  'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY',
  'https://mainnet-backup.helius-rpc.com/?api-key=YOUR_API_KEY'
]);

Performance überwachen

RPC-Nutzung erfassen

class RPCMonitor {
  private metrics = {
    calls: 0,
    errors: 0,
    totalLatency: 0
  };

  async monitoredCall<T>(operation: () => Promise<T>): Promise<T> {
    const start = Date.now();
    this.metrics.calls++;
    
    try {
      const result = await operation();
      this.metrics.totalLatency += Date.now() - start;
      return result;
    } catch (error) {
      this.metrics.errors++;
      throw error;
    }
  }

  getStats() {
    return {
      ...this.metrics,
      averageLatency: this.metrics.totalLatency / this.metrics.calls,
      errorRate: this.metrics.errors / this.metrics.calls
    };
  }
}

Best Practices

Commitment-Stufen

processed
confirmed
finalized

Verwenden für: WebSocket-Abonnements, Echtzeitaktualisierungen
Latenz: ~400 ms
Zuverlässigkeit: Für die meisten Anwendungen geeignet

Ressourcenverwaltung

Fehlerbehandlung

// Implement robust error handling
async function robustRPCCall<T>(operation: () => Promise<T>): Promise<T> {
  try {
    return await operation();
  } catch (error) {
    if (error.code === -32602) {
      // Invalid params - fix request
      throw new Error('Invalid RPC parameters');
    } else if (error.code === -32005) {
      // Node behind - retry with different node
      throw new Error('Node synchronization issue');
    } else if (error.message.includes('429')) {
      // Rate limit - implement backoff
      throw new Error('Rate limited');
    }
    throw error;
  }
}

Häufige Fehler vermeiden

Vermeide diese häufigen Fehler:

Polling statt WebSocket-Abonnements verwenden
Vollständige Account-Daten abrufen, obwohl nur ein Teil benötigt wird
Mehrere Abfragen nicht als Batch ausführen
Rate Limits ignorieren und keine geeignete Wiederholungslogik implementieren
Commitment finalized verwenden, obwohl confirmed ausreicht
Abonnements nicht schließen und dadurch Speicherlecks verursachen

getTransactionsForAddress

Vollständiger Transaktionsverlauf mit Filterung, Sortierung und Unterstützung für Token-Accounts (exklusiv bei Helius)

getTransfersByAddress

Geparster Verlauf von Token- und SOL-Übertragungen für Zahlungen und Abgleiche (exklusiv bei Helius)

getTransaction

Vollständige Transaktionsdetails anhand der Signatur abrufen

getProgramAccounts

Alle Accounts abrufen, die einem Programm gehören

getTokenAccountsByOwner

Token-Accounts für eine Wallet abrufen

getMultipleAccountsInfo

Details mehrerer Accounts als Batch abrufen

getAccountInfo

Informationen zu einem einzelnen Account abrufen

accountSubscribe

Account-Änderungen über WebSocket abonnieren

programSubscribe

Änderungen an Programm-Accounts über WebSocket abonnieren

logsSubscribe

Transaktionsprotokolle über WebSocket abonnieren

Zusammenfassung

Mit diesen Optimierungstechniken kannst du Folgendes erreichen:

60–90 % weniger API-Aufrufe
Deutlich geringere Latenz bei Echtzeitvorgängen
Geringere Bandbreitennutzung durch gezielte Abfragen
Höhere Fehlertoleranz durch intelligente Wiederholungslogik
Niedrigere Betriebskosten durch effiziente Ressourcennutzung

Next Steps

Möchtest du diese Optimierungen implementieren? In unserem Leitfaden zur Transaktionsoptimierung findest du transaktionsspezifische Best Practices.

​Schnellstart

Transaction Optimization

Data Retrieval

Real-time Monitoring

Best Practices

​Transaktionsoptimierung

​Compute Units verwalten

​Priority Fees optimieren

​Best Practices zum Senden von Transaktionen

​Datenabruf optimieren

​Erweiterte Paginierungsmethoden (V2)

⚡ Performance Boost

​Datenabruf optimieren

​Effiziente Account-Abfragen

​Token-Guthaben abfragen

​Transaktionsverlauf

​Übertragungsverlauf

​Echtzeitüberwachung

​Account-Abonnements

​Programm-Accounts überwachen

​Transaktionen überwachen

​Fortgeschrittene Muster

​Intelligente Wiederholungslogik

​Speichereffiziente Verarbeitung

​Connection-Pooling

​Performance überwachen

​RPC-Nutzung erfassen

​Best Practices

​Commitment-Stufen

​Ressourcenverwaltung

​Fehlerbehandlung

​Häufige Fehler vermeiden

​Verwandte Methoden

getTransactionsForAddress

getTransfersByAddress

getTransaction

getProgramAccounts

getTokenAccountsByOwner

getMultipleAccountsInfo

getAccountInfo

accountSubscribe

programSubscribe

logsSubscribe

​Zusammenfassung

Next Steps

Schnellstart

Transaktionsoptimierung

Compute Units verwalten

Priority Fees optimieren

Best Practices zum Senden von Transaktionen

Datenabruf optimieren

Erweiterte Paginierungsmethoden (V2)

Datenabruf optimieren

Effiziente Account-Abfragen

Token-Guthaben abfragen

Transaktionsverlauf

Übertragungsverlauf

Echtzeitüberwachung

Account-Abonnements

Programm-Accounts überwachen

Transaktionen überwachen

Fortgeschrittene Muster

Intelligente Wiederholungslogik

Speichereffiziente Verarbeitung

Connection-Pooling

Performance überwachen

RPC-Nutzung erfassen

Best Practices

Commitment-Stufen

Ressourcenverwaltung

Fehlerbehandlung

Häufige Fehler vermeiden

Verwandte Methoden

Zusammenfassung