> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Sender Max : Transaction Solana la Plus Rapide

> Envoyez des transactions et des paquets Solana via le niveau d'atterrissage le plus rapide de Helius Sender — chaque voie de routage à chaque soumission, avec un pourboire minimum de 0,001 SOL.

## Présentation

<Note>
  **Mise à jour des prix :** Sender Max utilise désormais un pourboire minimum de **0,001 SOL**. Cela
  vous permet d'entrer dans un tampon de pourboires prioritaires en haut du bloc — donnez plus pour être le premier.
</Note>

Sender Max est le niveau de performance le plus élevé de [Helius Sender](/docs/fr/sending-transactions/sender), conçu pour les soumissions qui doivent atterrir avant la concurrence. Il achemine votre soumission à travers chaque voie rapide disponible et l'introduit dans un tampon de pourboires prioritaires qui favorise les pourboires les plus élevés.

Sender Max gère à la fois **les transactions individuelles et les paquets**. Les deux utilisent toutes les voies (Helius, Jito, Harmonic, Rakurai, etc.) — la seule différence est la charge utile : soumettez une transaction avec `sendTransaction`, ou jusqu'à quatre avec `sendBundle`.

Ce niveau exige un pourboire minimum de **0,001 SOL**. Pour un envoi optimisé par coût sur un seul chemin, utilisez le niveau [SWQOS-only](/docs/fr/sending-transactions/sender-swqos-only) à la place.

<CardGroup cols={2}>
  <Card title="Atterrissage le Plus Rapide" icon="trophy">
    Acheminé à travers chaque voie rapide pour la probabilité maximale
    d'atterrissage
  </Card>

  <Card title="Tampon de Pourboires Prioritaires" icon="arrow-up-wide-short">
    Votre soumission entre dans un tampon de pourboires prioritaires qui
    privilégie les soumissions au plus haut pourboire — donnez plus pour être le premier
  </Card>

  <Card title="Pas de Crédits" icon="coins">
    Disponible sur tous les forfaits sans consommer de crédits API
  </Card>

  <Card title="Pourboire Minimum de 0,001 SOL" icon="dollar-sign">
    Le pourboire minimum requis pour entrer dans le tampon de pourboires prioritaires et
    utiliser chaque voie de routage
  </Card>
</CardGroup>

## Comment ça fonctionne

Lorsque vous donnez au moins **0,001 SOL**, votre soumission — qu'il s'agisse d'une transaction unique ou d'un paquet — est acheminée à travers chaque voie rapide disponible et entre dans un tampon de pourboires prioritaires. Le tampon favorise les pourboires les plus élevés, donc augmenter votre pourboire au-delà du minimum augmente votre chance d'être le premier.

<Note>
  Les pourboires inférieurs à 0,001 SOL n'entrent pas dans le tampon de pourboires prioritaires — ils sont envoyés sur une base de meilleur effort par moins de voies. Pour une envoi prévisible à faible latence à un pourboire plus bas, utilisez le niveau [SWQOS-only](/docs/fr/sending-transactions/sender-swqos-only) (0,000005 SOL).
</Note>

## Quand utiliser Max

<CardGroup cols={2}>
  <Card title="Bon choix" icon="circle-check">
    Comptes très contestés, lancements de tokens compétitifs, liquidations, et toute
    transaction où être le premier vaut un pourboire plus élevé.
  </Card>

  <Card title="Envisagez SWQOS-only" icon="dollar-sign" href="/docs/fr/sending-transactions/sender-swqos-only">
    Flux sensibles aux coûts ou à volume élevé où un seul chemin rapide atterrit de manière fiable.
  </Card>
</CardGroup>

## Exigences

Chaque soumission Sender Max doit inclure :

* **Pourboire** : Un transfert de SOL d'au moins **0,001 SOL** vers un [compte de pourboire](/docs/fr/sending-transactions/sender#exigences) désigné. Dans un paquet, au moins une transaction doit contenir le pourboire.
* **Frais prioritaires** : Une instruction de prix par unité de calcul avec des frais prioritaires d'au moins **5,000 lamports**. Voir [Frais prioritaires](#frais-prioritaires).

Ignorer le prévol (`skipPreflight: true`) est optionnel mais recommandé — Les vérifications prévol augmentent la latence.

<Warning>
  Les transactions sans pourboire ni frais prioritaires seront rejetées. Pour
  les règles spécifiques aux paquets, voir [Paquets](#paquets).
</Warning>

## Frais prioritaires

Chaque transaction doit inclure des frais prioritaires d'au moins **5,000 lamports**, et nous recommandons **au moins 10,000 lamports** pour un atterrissage plus fiable. Le pourboire introduit votre transaction dans le tampon de pourboires prioritaires, tandis que les frais prioritaires augmentent sa priorité dans le planificateur du validateur — ensemble, ils maximisent vos chances d'atterrir.

Fixez des frais prioritaires avec une instruction de prix par unité de calcul. Vos frais prioritaires totaux sont le prix par unité de calcul (en micro-lamports) multiplié par votre limite d'unités de calcul :

```typescript theme={"system"}
import { ComputeBudgetProgram } from "@solana/web3.js";

ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 });
```

Utilisez l'[API des Frais Prioritaires de Helius](/docs/fr/priority-fee-api) pour des recommandations de frais en temps réel basées sur les conditions actuelles du réseau.

## Points de Terminaison

Utilisez le point de terminaison HTTPS global pour les frontends, ou le point de terminaison HTTP régional le plus proche de vos serveurs pour les backends.

**Frontend / navigateur (HTTPS global) :**

```
https://sender.helius-rpc.com/fast
```

**Backend / serveur (HTTP régional) :**

```
http://slc-sender.helius-rpc.com/fast   # Salt Lake City
http://ewr-sender.helius-rpc.com/fast   # Newark
http://lon-sender.helius-rpc.com/fast   # London
http://fra-sender.helius-rpc.com/fast   # Frankfurt
http://ams-sender.helius-rpc.com/fast   # Amsterdam
http://sg-sender.helius-rpc.com/fast    # Singapore
http://tyo-sender.helius-rpc.com/fast   # Tokyo
```

Voir la [référence des points de terminaison Sender](/docs/fr/sending-transactions/sender#points-daccès) pour le réchauffement de connexion et les détails.

<Tip>
  Vous voulez éviter les validateurs liés aux attaques sandwich ? Ajoutez
  [`mev-protect=true`](/docs/fr/sending-transactions/mev-protect) à l'URL du point de terminaison —
  cela fonctionne à la fois pour `sendTransaction` et `sendBundle` :
  `https://sender.helius-rpc.com/fast?mev-protect=true`.
</Tip>

## Exemple de Code

<Tabs>
  <Tab title="@solana/web3.js">
    ```typescript [expandable] theme={"system"}
    import { 
      Connection, 
      TransactionMessage,
      VersionedTransaction,
      SystemProgram, 
      PublicKey,
      Keypair,
      LAMPORTS_PER_SOL,
      ComputeBudgetProgram
    } from '@solana/web3.js';
    import bs58 from 'bs58';

    const PRIV_B58 = 'Your Private Key';
    const RECIPIENT = 'Recipient Address';
    const HELIUS_API_KEY = 'Your API Key';
    const TIP_ACCOUNTS = [
      "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
      "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
      "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
      "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
      "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
      "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
      "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
      "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
      "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
      "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
    ];

    async function sendWithSenderMax(
      keypair: Keypair,
      recipientAddress: string
    ): Promise<string> {
      const connection = new Connection(
        `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`
      );

      const { value: { blockhash } } = await connection.getLatestBlockhashAndContext('confirmed');

      // Build transaction: priority fee + recipient transfer + 0.001 SOL tip
      const transaction = new VersionedTransaction(
        new TransactionMessage({
          instructions: [
            ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
            ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
            SystemProgram.transfer({
              fromPubkey: keypair.publicKey,
              toPubkey: new PublicKey(recipientAddress),
              lamports: 0.001 * LAMPORTS_PER_SOL,
            }),
            SystemProgram.transfer({
              fromPubkey: keypair.publicKey,
              toPubkey: new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
              lamports: 0.001 * LAMPORTS_PER_SOL, // Minimum tip to enter the priority tip buffer
            })
          ],
          payerKey: keypair.publicKey,
          recentBlockhash: blockhash,
        }).compileToV0Message()
      );

      transaction.sign([keypair]);

      // Frontend: use the global HTTPS endpoint to avoid CORS issues
      const SENDER_ENDPOINT = 'https://sender.helius-rpc.com/fast';
      // Backend: use the regional HTTP endpoint closest to your servers
      // const SENDER_ENDPOINT = 'http://slc-sender.helius-rpc.com/fast';

      const response = await fetch(SENDER_ENDPOINT, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          jsonrpc: '2.0',
          id: Date.now().toString(),
          method: 'sendTransaction',
          params: [
            Buffer.from(transaction.serialize()).toString('base64'),
            {
              encoding: 'base64',
              skipPreflight: true, // Optional: skip for lower latency
              maxRetries: 0
            }
          ]
        })
      });

      const json = await response.json();
      if (json.error) {
        throw new Error(json.error.message);
      }

      console.log('Transaction sent:', json.result);
      return json.result;
    }

    // Usage
    sendWithSenderMax(Keypair.fromSecretKey(bs58.decode(PRIV_B58)), RECIPIENT);
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={"system"}
    curl "https://sender.helius-rpc.com/fast" \
      -X POST \
      -H "Content-Type: application/json" \
      -d '{
        "jsonrpc": "2.0",
        "id": 1,
        "method": "sendTransaction",
        "params": [
          "BASE64_ENCODED_TRANSACTION",
          {
            "encoding": "base64",
            "skipPreflight": true,
            "maxRetries": 0
          }
        ]
      }'
    ```
  </Tab>
</Tabs>

<Tip>
  Pour les transactions compétitives, le minimum de 0.001 SOL est peu probablement
  compétitif. Évaluez votre pourboire en fonction de la valeur de la transaction que vous
  essayez d'atterrir — plus un atterrissage réussi vaut pour vous, plus vous
  devriez donner. Le minimum est un plancher, pas un objectif.
</Tip>

## Paquets

Un paquet est juste une autre charge utile acceptée par Sender Max. Soumettez jusqu'à 4 transactions entièrement signées et elles s'exécutent de manière atomique (tout ou rien) dans l'ordre, inscrites dans le **même tampon de pourboires prioritaires** qu'une transaction unique — le tampon priorise les paquets aux pourboires les plus élevés pour l'atterrissage le plus rapide.

<Warning>
  **Fournissez seulement le pourboire de 0,001 SOL pour Sender.** Sender Max
  achemine votre paquet à travers chaque voie rapide et ajoute les pourboires de voie
  pour vous — vous n'ajoutez pas un pourboire Jito séparé, n'utilisez pas de comptes de pourboires Jito,
  ni ne définissez l'en-tête `jito-region`.
  Ceux-ci s'appliquent uniquement aux [paquets basiques](/docs/fr/sending-transactions/send-bundle).
</Warning>

### Exigences

* **Jusqu'à 4 transactions**, entièrement signées. Elles s'exécutent séquentiellement et de manière atomique — si l'une échoue, tout le paquet est rejeté.
* **Pourboire** : au moins une transaction doit transférer au moins **0,001 SOL** vers un [compte de pourboire Sender](/docs/fr/sending-transactions/sender#exigences) désigné. Il s'agit du même pourboire Sender utilisé pour les transactions simples — Helius ajoute les pourboires de voie (y compris Jito) pour vous, donc vous n'ajoutez pas de pourboire Jito séparé.
* **Frais prioritaires** : chaque transaction doit inclure des [frais prioritaires](#frais-prioritaires) d'au moins **5,000 lamports**.

### Soumission

Envoyez au point de terminaison Sender avec `method: "sendBundle"`. Utilisez le point de terminaison HTTPS global pour les frontends, ou tout [point de terminaison régional](#points-de-terminaison) pour les backends — toutes les régions Sender sont prises en charge.

<Tabs>
  <Tab title="@solana/web3.js">
    ```typescript [expandable] theme={"system"}
    import { 
      Connection, 
      TransactionMessage,
      VersionedTransaction,
      SystemProgram, 
      PublicKey,
      Keypair,
      LAMPORTS_PER_SOL,
      ComputeBudgetProgram
    } from '@solana/web3.js';
    import bs58 from 'bs58';

    const PRIV_B58 = 'Your Private Key';
    const HELIUS_API_KEY = 'Your API Key';
    const TIP_ACCOUNTS = [
      "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
      "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
      "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
      "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
      "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
      "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
      "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
      "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
      "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
      "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
    ];

    async function sendBundleWithSenderMax(keypair: Keypair): Promise<string[]> {
      const connection = new Connection(
        `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`
      );

      const { value: { blockhash } } = await connection.getLatestBlockhashAndContext('confirmed');

      const tipAccount = new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]);

      // Transaction 1: your instructions + priority fee + the 0.001 SOL Sender tip
      const tx1 = new VersionedTransaction(
        new TransactionMessage({
          instructions: [
            ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
            ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
            // ... your instructions here ...
            SystemProgram.transfer({
              fromPubkey: keypair.publicKey,
              toPubkey: tipAccount,
              lamports: 0.001 * LAMPORTS_PER_SOL, // Sender tip — only one tx in the bundle needs it
            })
          ],
          payerKey: keypair.publicKey,
          recentBlockhash: blockhash,
        }).compileToV0Message()
      );
      tx1.sign([keypair]);

      // Transaction 2: more instructions — executes after tx1, atomically
      const tx2 = new VersionedTransaction(
        new TransactionMessage({
          instructions: [
            ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
            // ... your instructions here ...
          ],
          payerKey: keypair.publicKey,
          recentBlockhash: blockhash,
        }).compileToV0Message()
      );
      tx2.sign([keypair]);

      // Serialize each fully-signed transaction (up to 4) to base64
      const bundle = [tx1, tx2].map((tx) => Buffer.from(tx.serialize()).toString('base64'));

      const response = await fetch('https://sender.helius-rpc.com/fast', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          jsonrpc: '2.0',
          id: Date.now().toString(),
          method: 'sendBundle',
          params: [bundle, { encoding: 'base64' }]
        })
      });

      const json = await response.json();
      if (json.error) {
        throw new Error(json.error.message);
      }

      // Track landing by each transaction's signature (see below)
      const signatures = [tx1, tx2].map((tx) => bs58.encode(tx.signatures[0]));
      console.log('Bundle submitted:', signatures);
      return signatures;
    }

    // Usage
    sendBundleWithSenderMax(Keypair.fromSecretKey(bs58.decode(PRIV_B58)));
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={"system"}
    curl "https://sender.helius-rpc.com/fast" \
      -X POST \
      -H "Content-Type: application/json" \
      -d '{
        "jsonrpc": "2.0",
        "id": 1,
        "method": "sendBundle",
        "params": [
          [
            "BASE64_SIGNED_TX_1",
            "BASE64_SIGNED_TX_2"
          ],
          { "encoding": "base64" }
        ]
      }'
    ```
  </Tab>
</Tabs>

### Suivi de l'atterrissage

Suivez un paquet de la même manière que vous suivez une transaction unique — en surveillant la signature de chaque transaction pour qu'elle atterrisse. Étant donné que le paquet est atomique, confirmer une transaction signifie que tout le paquet a atterri. Vous ne devez **pas** utiliser `getBundleStatuses` ou un identifiant de paquet.

Utilisez la méthode qui convient à votre pile :

* Interrogez [`getSignatureStatuses`](/docs/fr/api-reference/rpc/http/getsignaturestatuses) jusqu'à ce que la signature soit confirmée.
* Abonnez-vous à [LaserStream](/docs/fr/laserstream) ou [LaserStream WebSocket](/docs/fr/rpc/websocket) et regardez la signature atterrie.
* Utilisez [Shred Delivery](/docs/fr/shred-delivery/raw-shreds) ou tout autre produit de streaming Helius qui expose les signatures atterries.

## Bonnes Pratiques

* **Sélection du point de terminaison** : Utilisez `https://sender.helius-rpc.com/fast` pour les applications frontend pour éviter les problèmes de CORS. Pour les applications backend, utilisez le point de terminaison HTTP régional le plus proche de vos serveurs.
* **Pourboire dynamique** : Augmentez votre pourboire au-dessus de 0.001 SOL pour les transactions très contestées afin d'améliorer votre priorité dans le tampon de pourboires.
* **Réchauffement de connexion** : Utilisez le [point de terminaison `/ping`](/docs/fr/sending-transactions/sender#réchauffement-de-connexion) pendant les périodes d'inactivité de plus de 5 secondes.
* **Frais prioritaires** : Utilisez l'[API des Frais Prioritaires de Helius](/docs/fr/priority-fee-api) pour des recommandations en temps réel.
* **Reprises** : Réglez `maxRetries: 0` et implémentez votre propre logique de reprise.

## Connexes

<CardGroup cols={2}>
  <Card title="Présentation de Sender" icon="rocket" href="/docs/fr/sending-transactions/sender">
    Concepts partagés : points de terminaison, réchauffement de connexion, limites de taux, et TPS personnalisé.
  </Card>

  <Card title="Niveau SWQOS-Only" icon="dollar-sign" href="/docs/fr/sending-transactions/sender-swqos-only">
    Envoi optimisé pour le coût à faible latence sur un seul chemin (pourboire min 0,000005 SOL).
  </Card>

  <Card title="Protection MEV" icon="shield-halved" href="/docs/fr/sending-transactions/mev-protect">
    Contourner les validateurs statistiquement liés aux attaques sandwich.
  </Card>
</CardGroup>