Solana RPC-Optimierung: Leistungs- & Kostenbewährte Verfahren

Die Optimierung der RPC-Nutzung kann die Leistung erheblich verbessern, Kosten senken und das Benutzererlebnis verbessern. Dieser Leitfaden behandelt bewährte Techniken für effiziente Solana RPC-Interaktionen.

Schnellstart

Transaktionsoptimierung

Optimieren Sie Compute-Einheiten, Prioritätsgebühren und das Senden von Transaktionen

Datenabfrage

Effiziente Muster zum Abrufen von Konto- und Programmdaten

Echtzeitüberwachung

WebSocket-Abonnements und Streaming-Datenoptimierung

Best Practices

Leistungsrichtlinien und Ressourcenmanagement

Transaktionsoptimierung

Verwaltung von Compute-Einheiten

1. Simulieren, um den tatsächlichen Verbrauch zu bestimmen:

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

2. Angemessene Limits mit Puffer setzen:

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

Optimierung der Prioritätsgebühr

1. Dynamische Gebührenschätzungen erhalten:

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. Die Prioritätsgebühr anwenden:

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

Best Practices beim Versenden von Transaktionen

Standardansatz
Mit Bestätigung

// 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
});

Datenabrufoptimierung

Erweiterte Paginierungsmethoden (V2)

Für groß angelegte Datenabfragen verwenden Sie die neuen V2-Methoden mit Cursor-basierter Paginierung:

⚡ Leistungssteigerung

getProgramAccountsV2 und getTokenAccountsByOwnerV2 bieten signifikante Leistungsverbesserungen für Anwendungen, die mit großen Datensätzen arbeiten:

Konfigurierbare Grenzen: 1-10.000 Konten pro Anfrage
Cursor-basierte Paginierung: Verhindert Timeouts bei großen Abfragen
Inkrementelle Updates: Nutzen Sie changedSinceSlot für die Echtzeitsynchronisierung
Bessere Speichernutzung: Stream-Daten anstatt alles auf einmal zu laden

Beispiel: Effiziente Programmkontoabfrage

// ❌ 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 Updates 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
      }
    ]
  })
});

Datenabrufoptimierung

Effiziente Kontoabfragen

Einzelkonto
Mehrere Konten
Programmkonten

// 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-Saldo-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

Für den vollständigen Adressverlauf verwenden Sie getTransactionsForAddress — eine ausschließlich bei Helius verfügbare Methode, die vollständige Transaktionsdaten, einschließlich zugehöriger Token-Kontobewegungen, in einem einzigen Aufruf zurückgibt:

// 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 Sie nur Token- oder SOL-Bewegungen benötigen — Zahlungen, Portfolioaktivität, Bilanzabstimmungen — verwenden Sie getTransfersByAddress (exklusiv bei Helius, erfordert einen Entwicklerplan oder höher). Es gibt geparste, für Menschen lesbare Übertragungsobjekte mit Eigentümern, Mints, Beträgen und Dezimalstellen zurück, sodass Sie die Transaktionsanalyse vollständig überspringen können:

// 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: Verwenden Sie getTransactionsForAddress, wenn Sie vollständige Transaktionspayloads oder Nicht-Transfer-Aktivitäten benötigen, und getTransfersByAddress, wenn Sie saubere Übertragungsaufzeichnungen für Bücher und Zahlungstracking benötigen.

Echtzeitüberwachung

Kontoabonnements

// 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 }}
);

Programmkontoüberwachung

// 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'
  }
);

Transaktionsüberwachung

// 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
  }
});

Erweiterte 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;
      }
    }
  }
}

Speicher-effiziente 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...
}

Verbindungspooling

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'
]);

Leistungsüberwachung

RPC-Nutzung verfolgen

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

Verpflichtungsebenen

verarbeitet
bestätigt
abgeschlossen

Verwendung für: WebSocket-Abonnements, Echtzeit-Updates
Latenz: ~400ms
Zuverlässigkeit: Gut für die meisten Anwendungen

Ressourcenmanagement

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äufig zu vermeidende Fehler

Vermeiden Sie diese häufigen Fehler:

Polling statt Verwendung von WebSocket-Abonnements
Abrufen vollständiger Kontendaten, wenn nur Teilinformationen benötigt werden
Keine Nutzung von Batch-Operationen für mehrere Abfragen
Ignorieren von Ratenbegrenzungen und keine ordnungsgemäße Wiederholungslogik implementieren
Verwendung von finalized-Verpflichtung, wenn confirmed ausreichend ist
Nicht geschlossene Abonnements, die zu Speicherlecks führen

getTransactionsForAddress

Vollständige Transaktionshistorie mit Filterung, Sortierung und Unterstützung von Token-Konten (exklusiv bei Helius)

getTransfersByAddress

Geparste Token- und SOL-Transaktionshistorie für Zahlungen und Abstimmungen (exklusiv bei Helius)

getTransaction

Abrufen vollständiger Transaktionsdetails nach Signatur

getProgramAccounts

Abrufen aller von einem Programm verwalteten Konten

getTokenAccountsByOwner

Holen Sie sich Token-Konten für eine Wallet

getMultipleAccountsInfo

Batch-Abruf mehrerer Kontoinformationen

getAccountInfo

Informationen über ein einzelnes Konto abrufen

accountSubscribe

Abonnieren Sie Kontoänderungen über WebSocket

programSubscribe

Abonnieren Sie Änderungen bei Programmkonten über WebSocket

logsSubscribe

Abonnieren Sie Transaktionsprotokolle über WebSocket

Zusammenfassung

Durch die Implementierung dieser Optimierungstechniken können Sie folgende Vorteile erzielen:

60-90% Reduzierung des API-Aufrufvolumens
Deutlich niedrigere Latenz für Echtzeitoperationen
Reduzierte Bandbreitennutzung durch gezielte Abfragen
Bessere Fehlerresistenz mit intelligenter Wiederholungslogik
Niedrigere Betriebskosten durch effiziente Ressourcennutzung

Nächste Schritte

Bereit, diese Optimierungen zu implementieren? Sehen Sie sich unseren Transaktionsoptimierungs-Leitfaden für transaktionsspezifische Best Practices an.

​Schnellstart

Transaktionsoptimierung

Datenabfrage

Echtzeitüberwachung

Best Practices

​Transaktionsoptimierung

​Verwaltung von Compute-Einheiten

​Optimierung der Prioritätsgebühr

​Best Practices beim Versenden von Transaktionen

​Datenabrufoptimierung

​Erweiterte Paginierungsmethoden (V2)

⚡ Leistungssteigerung

​Datenabrufoptimierung

​Effiziente Kontoabfragen

​Token-Saldo-Abfragen

​Transaktionsverlauf

​Übertragungsverlauf

​Echtzeitüberwachung

​Kontoabonnements

​Programmkontoüberwachung

​Transaktionsüberwachung

​Erweiterte Muster

​Intelligente Wiederholungslogik

​Speicher-effiziente Verarbeitung

​Verbindungspooling

​Leistungsüberwachung

​RPC-Nutzung verfolgen

​Best Practices

​Verpflichtungsebenen

​Ressourcenmanagement

​Fehlerbehandlung

​Häufig zu vermeidende Fehler

​Verwandte Methoden

getTransactionsForAddress

getTransfersByAddress

getTransaction

getProgramAccounts

getTokenAccountsByOwner

getMultipleAccountsInfo

getAccountInfo

accountSubscribe

programSubscribe

logsSubscribe

​Zusammenfassung

Nächste Schritte

Schnellstart

Transaktionsoptimierung

Verwaltung von Compute-Einheiten

Optimierung der Prioritätsgebühr

Best Practices beim Versenden von Transaktionen

Datenabrufoptimierung

Erweiterte Paginierungsmethoden (V2)

Datenabrufoptimierung

Effiziente Kontoabfragen

Token-Saldo-Abfragen

Transaktionsverlauf

Übertragungsverlauf

Echtzeitüberwachung

Kontoabonnements

Programmkontoüberwachung

Transaktionsüberwachung

Erweiterte Muster

Intelligente Wiederholungslogik

Speicher-effiziente Verarbeitung

Verbindungspooling

Leistungsüberwachung

RPC-Nutzung verfolgen

Best Practices

Verpflichtungsebenen

Ressourcenmanagement

Fehlerbehandlung

Häufig zu vermeidende Fehler

Verwandte Methoden

Zusammenfassung