Échanges de terrains avec Sender

Sender soumet simultanément votre transaction à travers chaque voie à grande vitesse (Helius, Jito, Harmonic, Rakurai) et ne consomme aucun crédit API. Vous payez par envoi avec un pourboire en SOL. Ce guide construit une boucle d’envoi en production avec des connexions chaudes, des frais à prix réel et une confirmation avec une politique de nouvelle tentative.

Choisissez votre niveau

Sender Max (pourboire minimum de 0,001 SOL) s’adresse à toutes les voies et entre dans le tampon de pourboires prioritaires, où un plus grand pourboire atterrit en premier. SWQOS-only (0,000005 SOL) prend une seule voie rapide pour un flux optimisé en termes de coûts. Ajoutez ?swqos_only=true à l’URL du point de terminaison. Les pourboires entre les deux minimums sont des meilleurs efforts à travers moins de voies, donc choisissez l’un ou l’autre niveau.

Choisissez votre point de terminaison

Les backends doivent utiliser le point de terminaison HTTP régional le plus proche de leurs serveurs (http://ewr-sender.helius-rpc.com/fast, fra, slc, ams, lon, sg, tyo). Les navigateurs doivent utiliser le point de terminaison HTTPS global https://sender.helius-rpc.com/fast, qui s’auto-route et évite les problèmes CORS.

Préchauffez la connexion

Une poignée de main TCP/TLS à froid ajoute une latence au premier envoi après une période d’inactivité. Si votre système peut dépasser environ 5 secondes entre les envois, gardez la connexion chaude avec le point de terminaison ping :

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

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

Construisez la transaction

Chaque transaction Sender doit inclure à la fois un transfert de pourboire à un compte de pourboire désigné et un prix d’unité de calcul. Sender rejette les transactions manquant soit l’un soit l’autre. Le codage en dur des frais de priorité vous fait surpayer sur les marchés calmes et perdre des courses sur les marchés chargés, alors fixez-les à partir de l’API des frais de priorité :

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=YOUR_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;
}

Le pourboire détermine quelles voies votre transaction peut emprunter, et les frais de priorité augmentent sa position dans la file d’attente du validateur. Ensemble, ils maximisent la probabilité d’inclusion.

Envoyer, puis confirmer

Soumettez avec skipPreflight: true pour échanger la validation côté client contre la latence, puis confirmez via votre connexion RPC. Sender renvoie immédiatement la signature, ce qui n’est pas une preuve d’atterrissage :

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`, {
    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;
}

Avec maxRetries: 0 vous possédez la politique de nouvelle tentative : lorsque la confirmation expire, reconstruisez avec un nouveau blockhash et des frais réévalués au lieu de renvoyer la transaction obsolète. Le débit par défaut est de 50 TPS. Les plans professionnels peuvent demander des limites plus élevées.

Optionnel : contournez les attaquants en sandwich

Ajoutez ?mev-protect=true à l’URL du point de terminaison pour éviter les validateurs statistiquement liés aux attaques sandwich. Le corps de la requête reste inchangé, et cela fonctionne sur les deux niveaux :

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

Voir MEV Protect pour les compromis. Pour une exécution multi-transaction atomique (jusqu’à 4 transactions, tout-ou-rien), utilisez sendBundle sur le même point de terminaison.

Guides connexes

Aperçu de Sender

Niveaux, points de terminaison, comptes de pourboires et limites de taux en entier

Échanger sur les pré-confirmations

Associer le chemin d’envoi le plus rapide avec le signal de transaction le plus tôt

Commencez ici

Données en temps réel

Trading à faible latence

Données historiques et de portefeuille

Guides des méthodes RPC

Préparation à la production

Utilisation d'Orb

Autres modes d'emploi

Échanges de terrains avec Sender

Choisissez votre niveau

Choisissez votre point de terminaison

Préchauffez la connexion

Construisez la transaction

Envoyer, puis confirmer

Optionnel : contournez les attaquants en sandwich

Guides connexes

Aperçu de Sender

Échanger sur les pré-confirmations

​Choisissez votre niveau

​Choisissez votre point de terminaison

​Préchauffez la connexion

​Construisez la transaction

​Envoyer, puis confirmer

​Optionnel : contournez les attaquants en sandwich

​Guides connexes

Aperçu de Sender

Échanger sur les pré-confirmations

Choisissez votre niveau

Choisissez votre point de terminaison

Préchauffez la connexion

Construisez la transaction

Envoyer, puis confirmer

Optionnel : contournez les attaquants en sandwich

Guides connexes