Trades mit Sender landen

Sender übermittelt deine Transaktion gleichzeitig über alle Hochgeschwindigkeitswege (Helius, Jito, Harmonic, Rakurai) und verbraucht keine API-Credits. Du bezahlst pro Sendevorgang mit einem SOL-Tip. Dieser Leitfaden zeigt dir, wie du eine produktionsreife Sendeschleife mit warmen Verbindungen, Gebühren auf Basis aktueller Preise und einer Bestätigung mit Wiederholungsrichtlinie baust.

Wähle deine Variante

Sender Max (Mindest-Tip von 0.001 SOL) leitet Transaktionen über alle Wege weiter und reiht sie in den Prioritäts-Tip-Puffer ein. Ein höherer Tip wird zuerst aufgenommen. Nur SWQOS (0.000005 SOL) nutzt einen einzelnen schnellen Weg für einen kostenoptimierten Ablauf. Füge ?swqos_only=true zur URL des endpoint hinzu. Tips zwischen den beiden Mindestbeträgen werden nach dem Best-Effort-Prinzip über weniger Wege verarbeitet. Wähle daher eine der beiden Varianten.

Wähle deinen endpoint

Backends sollten den regionalen HTTP endpoint verwenden, der ihren Servern am nächsten ist (http://ewr-sender.helius-rpc.com/fast, fra, slc, ams, lon, sg, tyo). Browser sollten den globalen HTTPS endpoint https://sender.helius-rpc.com/fast verwenden. Er übernimmt das Routing automatisch und vermeidet CORS-Probleme.

Halte die Verbindung warm

Ein neuer TCP/TLS-Handshake erhöht die Latenz des ersten Sendevorgangs nach einer Leerlaufphase. Wenn zwischen Sendevorgängen mehr als etwa 5 Sekunden liegen können, halte die Verbindung mit dem Ping-endpoint warm:

const SENDER = 'http://ewr-sender.helius-rpc.com';
const HELIUS_API_KEY = 'YOUR_API_KEY';

setInterval(async () => {
  try {
    await fetch(`${SENDER}/ping`);
  } catch (e) {
    console.warn('warm-up failed:', e);
  }
}, 5_000);

Baue die Transaktion

Jede Sender-Transaktion muss sowohl eine Tip-Überweisung an ein festgelegtes Tip-Konto als auch einen Preis pro Compute Unit enthalten. Sender lehnt Transaktionen ab, wenn eine der beiden Angaben fehlt. Wenn du die Prioritätsgebühr fest codierst, zahlst du in ruhigen Märkten zu viel und verlierst in stark ausgelasteten Märkten den Wettlauf. Ermittle sie daher über die API für Prioritätsgebühren:

send.ts

import {
  Connection, TransactionMessage, VersionedTransaction,
  SystemProgram, PublicKey, Keypair, ComputeBudgetProgram, LAMPORTS_PER_SOL
} from '@solana/web3.js';

const RPC = `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`;
const TIP_ACCOUNTS = [
  '4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE',
  'D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ',
  '9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta'
];

async function buildTransaction(keypair: Keypair, tradeInstructions: any[]) {
  const connection = new Connection(RPC);
  const { blockhash } = await connection.getLatestBlockhash('confirmed');

  // Price the fee against the accounts the trade touches
  const feeRes = await fetch(RPC, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0', id: '1', method: 'getPriorityFeeEstimate',
      params: [{
        accountKeys: tradeInstructions.flatMap(ix => ix.keys.map((k: any) => k.pubkey.toBase58())),
        options: { recommended: true }
      }]
    })
  });
  const { result } = await feeRes.json();

  const tx = new VersionedTransaction(
    new TransactionMessage({
      instructions: [
        ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
        ComputeBudgetProgram.setComputeUnitPrice({ microLamports: result.priorityFeeEstimate }),
        ...tradeInstructions,
        SystemProgram.transfer({
          fromPubkey: keypair.publicKey,
          toPubkey: new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
          lamports: 0.001 * LAMPORTS_PER_SOL // Sender Max minimum; tip more to land first
        })
      ],
      payerKey: keypair.publicKey,
      recentBlockhash: blockhash
    }).compileToV0Message()
  );
  tx.sign([keypair]);
  return tx;
}

Der Tip bestimmt, welche Wege deine Transaktion nutzen kann. Die Prioritätsgebühr verbessert ihre Position in der Warteschlange des Validators. Zusammen maximieren sie die Wahrscheinlichkeit der Aufnahme.

Sende und bestätige anschließend

Sende mit skipPreflight: true, um die clientseitige Validierung zugunsten einer niedrigeren Latenz zu überspringen. Bestätige die Transaktion anschließend über deine RPC-Verbindung. Sender gibt die Signatur sofort zurück. Das beweist jedoch nicht, dass die Transaktion aufgenommen wurde:

async function sendAndConfirm(tx: VersionedTransaction): Promise<string> {
  const signature = await send(tx);

  const connection = new Connection(RPC);
  for (let i = 0; i < 30; i++) {
    const { value } = await connection.getSignatureStatuses([signature]);
    const status = value[0];
    if (status?.err) throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
    if (status?.confirmationStatus === 'confirmed' || status?.confirmationStatus === 'finalized') {
      return signature;
    }
    await new Promise(r => setTimeout(r, 1_000));
  }
  throw new Error('Not confirmed within 30s: rebuild with a fresh blockhash and resend');
}

async function send(tx: VersionedTransaction): Promise<string> {
  const res = await fetch(`${SENDER}/fast?api-key=${HELIUS_API_KEY}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: Date.now().toString(),
      method: 'sendTransaction',
      params: [
        Buffer.from(tx.serialize()).toString('base64'),
        { encoding: 'base64', skipPreflight: true, maxRetries: 0 }
      ]
    })
  });
  const json = await res.json();
  if (json.error) throw new Error(json.error.message);
  return json.result;
}

Mit maxRetries: 0 steuerst du die Wiederholungsrichtlinie selbst: Wenn die Bestätigung in einen timeout läuft, baue die Transaktion mit einem neuen Blockhash und einer neu berechneten Gebühr erneut, anstatt die veraltete Transaktion noch einmal zu senden. Requests mit deinem bestehenden Helius-Projekt-API key sind pro Region auf 50 Requests pro Sekunde begrenzt. Requests ohne API key sind pro Region auf 1 Request pro Sekunde und Egress-IP begrenzt. Mit Professional-Tarifen kannst du höhere Limits anfragen.

Optional: Umgehe Sandwich-Angreifer

Füge ?mev-protect=true zur URL des endpoint hinzu, um Validatoren zu vermeiden, die statistisch mit Sandwich-Angriffen in Verbindung stehen. Der Body des request bleibt unverändert. Die Option funktioniert mit beiden Varianten:

http://ewr-sender.helius-rpc.com/fast?mev-protect=true

Unter MEV Protect findest du die jeweiligen Vor- und Nachteile. Verwende für die atomare Ausführung mehrerer Transaktionen (bis zu 4 Transaktionen, entweder alle oder keine) sendBundle mit demselben endpoint.

Sender overview

Vollständige Informationen zu Varianten, endpoints, Tip-Konten und rate limits

Trade on Preconfirmations

Kombiniere den schnellsten Sendeweg mit dem frühesten Transaktionssignal

Hier starten

Echtzeitdaten

Trading mit niedriger Latenz

Historische Daten und Wallet-Daten

Anleitungen zu RPC-Methoden

Produktionsreife

Orb verwenden

Weitere Anleitungen

Trades mit Sender landen

Wähle deine Variante

Wähle deinen endpoint

Halte die Verbindung warm

Baue die Transaktion

Sende und bestätige anschließend

Optional: Umgehe Sandwich-Angreifer

Verwandte Leitfäden

Sender overview

Trade on Preconfirmations

​Wähle deine Variante

​Wähle deinen endpoint

​Halte die Verbindung warm

​Baue die Transaktion

​Sende und bestätige anschließend

​Optional: Umgehe Sandwich-Angreifer

​Verwandte Leitfäden

Sender overview

Trade on Preconfirmations

Wähle deine Variante

Wähle deinen endpoint

Halte die Verbindung warm

Baue die Transaktion

Sende und bestätige anschließend

Optional: Umgehe Sandwich-Angreifer

Verwandte Leitfäden