> ## 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: Transação Solana de Aterrissagem Mais Rápida

> Envie transações Solana e pacotes através do nível de aterrissagem mais rápido do Helius Sender. Acesse todos os caminhos (Helius, Jito, Harmonic, Rakurai, etc.) para cada envio, com um mínimo de gorjeta de 0,001 SOL.

## Visão Geral

<Note>
  **Atualização de preços:** O Sender Max agora utiliza uma gorjeta mínima de
  **0,001 SOL**. Isso insere você em um buffer de gorjetas prioritário para o
  topo do bloco — dê uma gorjeta maior para chegar primeiro.
</Note>

Sender Max é o nível de maior desempenho do [Helius Sender](/docs/pt-BR/sending-transactions/sender), projetado para envios que precisam chegar antes da concorrência. Ele roteia seu envio por todos os caminhos de alta velocidade disponíveis e o insere em um buffer de gorjetas prioritário que favorece as gorjetas mais altas.

O Sender Max lida com **transações únicas e pacotes**. Ambos utilizam todos os caminhos (Helius, Jito, Harmonic, Rakurai, etc.) — a única diferença é a carga útil: envie uma transação com `sendTransaction` ou até quatro com `sendBundle`.

Este nível requer uma gorjeta mínima de **0,001 SOL**. Para envio otimizado por custo em um único caminho, use o nível [SWQOS-only](/docs/pt-BR/sending-transactions/sender-swqos-only) em vez disso.

<CardGroup cols={2}>
  <Card title="Aterrissagem Mais Rápida" icon="trophy">
    Roteado por todos os caminhos de alta velocidade para a maior probabilidade de
    aterrissagem
  </Card>

  <Card title="Buffer de Gorjeta Prioritário" icon="arrow-up-wide-short">
    Seu envio entra em um buffer de gorjetas prioritário que prioriza os envios
    com maiores gorjetas — dê mais gorjeta para chegar primeiro
  </Card>

  <Card title="Sem Créditos" icon="coins">
    Disponível em todos os planos sem consumir créditos da API
  </Card>

  <Card title="Gorjeta Mínima de 0,001 SOL" icon="dollar-sign">
    A gorjeta mínima necessária para entrar no buffer de gorjetas prioritário e
    usar todos os caminhos de roteamento
  </Card>
</CardGroup>

## Como funciona

Quando você dá uma gorjeta de pelo menos **0,001 SOL**, seu envio — seja uma transação única ou um pacote — é roteado por todos os caminhos de alta velocidade disponíveis e inserido em um buffer de gorjetas prioritário. O buffer favorece as gorjetas mais altas, então aumentar sua gorjeta acima do mínimo aumenta suas chances de chegar primeiro.

<Note>
  Gorjetas abaixo de 0,001 SOL não entram no buffer de gorjetas prioritário — são enviadas com o melhor esforço
  possível por menos caminhos. Para envio previsível de baixa latência com uma
  gorjeta menor, use o nível [SWQOS-only](/docs/pt-BR/sending-transactions/sender-swqos-only)
  (0,000005 SOL).
</Note>

## Quando usar Max

<CardGroup cols={2}>
  <Card title="Boa escolha" icon="circle-check">
    Contas altamente disputadas, lançamentos de tokens competitivos, liquidações e qualquer
    transação onde chegar primeiro vale uma gorjeta maior.
  </Card>

  <Card title="Considere SWQOS-only" icon="dollar-sign" href="/docs/pt-BR/sending-transactions/sender-swqos-only">
    Fluxos sensíveis ao custo ou de alto volume onde um único caminho rápido chega de forma confiável.
  </Card>
</CardGroup>

## Requisitos

Todo envio Sender Max deve incluir:

* **Gorjeta**: Uma transferência de SOL de pelo menos **0,001 SOL** para uma [conta de gorjeta](/docs/pt-BR/sending-transactions/sender#requirements) designada. Em um pacote, pelo menos uma transação deve incluir a gorjeta.
* **Taxa prioritária**: Uma instrução de preço de unidade de computação com uma taxa prioritária de pelo menos **5.000 lamports**. Veja [Taxas prioritárias](#priority-fees).

Pular a preflight (`skipPreflight: true`) é opcional, mas recomendado — as verificações de preflight aumentam a latência.

<Warning>
  Transações sem a gorjeta ou taxa prioritária serão rejeitadas. Para
  regras específicas de pacotes, veja [Pacotes](#bundles).
</Warning>

## Taxas prioritárias

Toda transação deve incluir uma taxa prioritária de pelo menos **5.000 lamports**, e recomendamos **pelo menos 10.000 lamports** para uma aterrissagem mais confiável. A gorjeta insere sua transação no buffer de gorjetas prioritário, enquanto a taxa prioritária eleva sua prioridade no agendador do validador — juntos, eles maximizam sua chance de aterrissagem.

Defina uma taxa prioritária com uma instrução de preço de unidade de computação. Sua taxa prioritária total é o preço da unidade de computação (em micro-lamports) multiplicado pelo seu limite de unidades de computação:

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

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

Use a [Helius Priority Fee API](/docs/pt-BR/priority-fee-api) para recomendações de taxas em tempo real com base nas condições atuais da rede.

## Endpoints

Use o endpoint global HTTPS para frontends, ou o endpoint regional HTTP mais próximo de seus servidores para backends.

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

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

**Backend / servidor (HTTP regional):**

```
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
```

Veja a [referência de endpoints Sender](/docs/pt-BR/sending-transactions/sender#endpoints) para aquecimento de conexão e detalhes.

<Tip>
  Quer evitar validadores vinculados a ataques de sanduíche? Adicione
  [`mev-protect=true`](/docs/pt-BR/sending-transactions/mev-protect) ao URL do endpoint —
  funciona para tanto `sendTransaction` como `sendBundle`:
  `https://sender.helius-rpc.com/fast?mev-protect=true`.
</Tip>

## Exemplo de Código

<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>
  Para transações competitivas, o mínimo de 0,001 SOL é improvável de ser
  competitivo. Defina sua gorjeta mais próxima do valor da transação que você está
  tentando enviar — quanto mais valer um aterrissamento bem-sucedido para você, maior
  deve ser sua gorjeta. O mínimo é um piso, não um alvo.
</Tip>

## Pacotes

Um pacote é apenas outra carga útil que o Sender Max aceita. Envie até 4 transações totalmente assinadas e elas executam-se atomicamente (tudo ou nada) na ordem, inseridas no **mesmo buffer de gorjetas prioritário** que uma transação única — o buffer prioriza os pacotes com gorjetas mais altas para a aterrissagem mais rápida.

<Warning>
  **Forneça apenas a gorjeta de 0,001 SOL do Sender.** O Sender Max roteia seu pacote
  por todos os caminhos de alta velocidade e adiciona quaisquer gorjetas de caminho em seu nome — você
  não adiciona uma gorjeta Jito separada, usa contas de gorjeta Jito ou define o cabeçalho `jito-region`.
  Essas se aplicam apenas a [pacotes básicos](/docs/pt-BR/sending-transactions/send-bundle).
</Warning>

### Requisitos

* **Até 4 transações**, totalmente assinadas. Elas são executadas sequencialmente e atomicamente — se qualquer falhar, todo o pacote é rejeitado.
* **Gorjeta**: pelo menos uma transação deve transferir pelo menos **0,001 SOL** para uma [conta de gorjeta Sender](/docs/pt-BR/sending-transactions/sender#requirements) designada. Esta é a mesma gorjeta Sender usada para transações únicas — Helius adiciona quaisquer gorjetas de caminho (incluindo Jito) para você, então você não adiciona uma gorjeta Jito separada.
* **Taxa prioritária**: cada transação deve incluir uma [taxa prioritária](#priority-fees) de pelo menos **5.000 lamports**.

### Enviar

Envie para o endpoint Sender com `method: "sendBundle"`. Use o endpoint global HTTPS para frontends, ou qualquer [endpoint regional](#endpoints) para backends — todas as regiões Sender são suportadas.

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

### Acompanhar a aterrissagem

Acompanhe um pacote da mesma forma que acompanha uma transação única — observando a assinatura de cada transação ser confirmada. Porque o pacote é atômico, confirmar qualquer uma das transações significa que todo o pacote foi realizado. Você **não** usa `getBundleStatuses` ou um ID de pacote.

Use o método que melhor se adapta ao seu stack:

* Faça polling de [`getSignatureStatuses`](/docs/pt-BR/api-reference/rpc/http/getsignaturestatuses) até a assinatura ser confirmada.
* Inscreva-se no [LaserStream](/docs/pt-BR/laserstream) ou [LaserStream WebSocket](/docs/pt-BR/rpc/websocket) e observe a assinatura ser confirmada.
* Use [Shred Delivery](/docs/pt-BR/shred-delivery/raw-shreds) ou qualquer outro produto de streaming Helius que exponha assinaturas confirmadas.

## Melhores Práticas

* **Seleção de endpoint**: Use `https://sender.helius-rpc.com/fast` para apps frontend para evitar problemas de CORS. Para apps backend, use o endpoint regional HTTP mais próximo de seus servidores.
* **Gorjeta dinâmica**: Aumente sua gorjeta acima de 0,001 SOL para transações altamente disputadas para melhorar sua prioridade no buffer de gorjetas.
* **Aquecimento de conexão**: Use o [endpoint `/ping`](/docs/pt-BR/sending-transactions/sender#connection-warming) durante períodos ociosos superiores a 5 segundos.
* **Taxas prioritárias**: Use a [Helius Priority Fee API](/docs/pt-BR/priority-fee-api) para recomendações em tempo real.
* **Repetições**: Configure `maxRetries: 0` e implemente sua própria lógica de repetição.

## Relacionados

<CardGroup cols={2}>
  <Card title="Visão Geral do Sender" icon="rocket" href="/docs/pt-BR/sending-transactions/sender">
    Conceitos compartilhados: endpoints, aquecimento de conexão, limites de taxa e TPS personalizado.
  </Card>

  <Card title="Nível SWQOS-Only" icon="dollar-sign" href="/docs/pt-BR/sending-transactions/sender-swqos-only">
    Envio otimizado por custo e baixa latência em um único caminho (mínimo de gorjeta de 0,000005 SOL).
  </Card>

  <Card title="MEV Protect" icon="shield-halved" href="/docs/pt-BR/sending-transactions/mev-protect">
    Roteie ao redor de validadores estatisticamente ligados a ataques de sanduíche.
  </Card>
</CardGroup>