Transaktionen und Gebühren

​

Transaktionsaufbau

• Message: die geordnete Liste der Instruktionen, die Konten, auf die sie verweisen, und den kürzlichen Blockhash.
• Signatures: eine pro Unterzeichner, bestätigen, dass die Transaktion autorisiert wurde.
• Recent blockhash: beweist, dass die Transaktion aktuell ist; Transaktionen mit veralteten Blockhashes (>150 Slots alt) werden abgelehnt.

​

Instruktionen

• program_id — das aufzurufende Programm.
• accounts — die Konten (und deren writable/signer-Flags) die das Programm berühren darf.
• data — undurchsichtige Bytes, die das Programm interpretiert.

1. ComputeBudget::SetComputeUnitLimit — erhöht das Standard-CU-Limit.
2. ComputeBudget::SetComputeUnitPrice — setzt eine Prioritätsgebühr.
3. Optional CreateAssociatedTokenAccount — erstellt das Ausgabe-ATA, falls der Benutzer noch keine hat.
4. Raydium::SwapBaseInput — führt den Swap aus.
5. Optional CloseAccount — schließt ein wrapped-SOL-ATA.

​

Konten in Transaktionen

• Signer / non-signer: muss der Inhaber des Kontos die Transaktion unterzeichnen?
• Writable / read-only: kann die Transaktion das Konto ändern?

​

Transaktionsgrößenlimit

​

Address Lookup Tables (ALTs)

• Eine Transaktion, die auf 20 Konten direkt verweist: ~640 B Pubkeys.
• Dieselbe Transaktion mit ALTs: ~20 B Indizes + ALT-Referenzen.

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

// SDK builds a v0 (versioned) tx with ALT references
const { transaction } = await raydium.trade.swap({ /* ... */ });
// transaction is a VersionedTransaction, not a legacy Transaction.

​

Compute Budget

• Standard: 200.000 CU pro Transaktion.
• Maximum: 1.400.000 CU pro Transaktion (erhöht über ComputeBudget::SetComputeUnitLimit).
• Pro-Block-Obergrenze: 48M CU pro Block (auf Protokollebene).

import { ComputeBudgetProgram } from "@solana/web3.js";

tx.add(
  ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }),
);

​

Prioritätsgebühren

priority_fee = compute_unit_price (micro-lamports) × compute_unit_limit

tx.add(
  ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 10_000 }),
);

​

Limits für Instruktions- und Kontoanzahl

• Max Konten pro Transaktion: 128.
• Max Konten pro Instruktion (CPI): 64.
• Max Instruktionen pro Transaktion: kein hartes Limit, nur durch das Größenlimit beschränkt.
• Max CPI-Tiefe: 4 (ein Programm kann ein anderes aufrufen, das wiederum ein anderes aufrufen kann, 4 Ebenen tief).

​

Gebührenkategorien bei einem Raydium-Swap

​

Solana-Netzwerkgebühren

• Basisgebühr pro Signature: 5000 Lamports pro Signature. Fast immer 1 Signature = 0,000005 SOL.
• Prioritätsgebühr: CU-Preis × CU-Limit in Microlamports. Variiert mit Stau; siehe integration-guides/priority-fee-tuning.

​

Raydium-Protokollgebühren

• Swap-Gebühr: Prozentsatz der Eingabe (CPMM typischerweise 0,25%, CLMM 0,01%–1% pro Stufe). Aufgeteilt zwischen LPs und Protokoll-Zielen. Siehe ray/protocol-fees.

​

Beispiel: $1000 USDC → SOL über CPMM 0,25%-Stufe

​

Versionierte Transaktionen

• Legacy: das ursprüngliche Format, kein ALT-Support.
• v0 (Versioned): unterstützt ALTs, erweiterbar für zukünftige Versionen.

// Building a v0 tx directly
import { VersionedTransaction, TransactionMessage } from "@solana/web3.js";

const msg = new TransactionMessage({
  payerKey:        owner.publicKey,
  recentBlockhash: blockhash,
  instructions:    [ /* ... */ ],
}).compileToV0Message([lookupTableAccount]);

const tx = new VersionedTransaction(msg);
tx.sign([owner]);

​

Blockhash-Aktualität

async function sendWithRetry(tx, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
    tx.message.recentBlockhash = blockhash;
    tx.sign([owner]);
    try {
      return await connection.sendRawTransaction(tx.serialize());
    } catch (e) {
      if (i === maxRetries - 1) throw e;
    }
  }
}

​

Parallele Ausführung

• Zwei Swaps auf dem gleichen Pool können nicht parallel ausgeführt werden — beide schreiben in den Pool-Status.
• Ein Swap auf Pool A und ein Swap auf Pool B führen parallel aus, wenn sich Kontolisten nicht überlappen.
• Eine schreibgeschützte Transaktion blockiert nie einen Writer auf dem gleichen Konto (schreibgeschützt ist konzurrent mit sich selbst, aber nicht mit Writes).

​

Transaktionsbestätigungsstufen

await connection.sendAndConfirmTransaction(tx, [owner], {
  commitment: "confirmed",
});

​

Simulation

const sim = await connection.simulateTransaction(tx);
console.log(sim.value.logs);
console.log(sim.value.unitsConsumed);

​

Verweise

• solana-fundamentals/account-model — Konten in Transaktionen.
• solana-fundamentals/pdas-and-cpis — wie Programme sich gegenseitig aufrufen.
• integration-guides/priority-fee-tuning — Anpassung von CU-Limits und Prioritätsgebühren.
• ray/protocol-fees — Raydium-Protokollgebührenstruktur.

• Solana Transaction docs.
• Address Lookup Tables proposal.
• Compute budget documentation.