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

# Comércio de Terras com Sender

> "Construa um loop de envio de baixa latência com Helius Sender: endpoints regionais, aquecimento de conexão, taxas de prioridade dinâmicas, gorjetas e confirmação de aterrissagem com tentativas."

Sender envia simultaneamente sua transação por todos os caminhos de alta velocidade (Helius, Jito, Harmonic, Rakurai) e não consome créditos de API. Você paga por envio com uma gorjeta em SOL. Este guia constrói um loop de envio em produção com conexões aquecidas, taxas com preços ao vivo e confirmação com uma política de tentativas.

## Escolha seu nível

[Sender Max](/docs/pt-BR/sending-transactions/sender-max) (gorjeta mínima de 0.001 SOL) roteia por todos os caminhos e entra no buffer de gorjeta prioritária, onde uma gorjeta maior pousa primeiro.

[Apenas SWQOS](/docs/pt-BR/sending-transactions/sender-swqos-only) (0.000005 SOL) usa um único caminho rápido para fluxo otimizado em custos. Adicione `?swqos_only=true` ao URL do endpoint.

Gorjetas entre os dois mínimos são melhor esforço por menos caminhos, então escolha um nível ou outro.

## Escolha seu endpoint

Os backends devem usar o endpoint HTTP regional mais próximo de seus servidores (`http://ewr-sender.helius-rpc.com/fast`, `fra`, `slc`, `ams`, `lon`, `sg`, `tyo`).

Os navegadores devem usar o endpoint global HTTPS `https://sender.helius-rpc.com/fast`, que roteia automaticamente e evita problemas de CORS.

## Aqueça a conexão

Um handshake TCP/TLS frio adiciona latência ao primeiro envio após um período ocioso.

Se seu sistema pode ficar mais de cerca de 5 segundos entre envios, mantenha a conexão aquecida com o endpoint ping:

```typescript theme={"system"}
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);
```

## Construa a transação

Toda transação Sender deve incluir tanto uma transferência de gorjeta para uma conta de gorjeta designada quanto um preço de unidade de computação. Sender rejeita transações que não possuem um dos dois.

Codificar a taxa de prioridade deixa você pagando demais em mercados tranquilos e perdendo corridas em mercados movimentados, então precifique-a a partir da [Priority Fee API](/docs/pt-BR/priority-fee-api):

```typescript send.ts theme={"system"}
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;
}
```

A gorjeta determina quais caminhos sua transação pode seguir, e a taxa de prioridade aumenta sua posição na fila do validador. Juntos, maximizam a probabilidade de inclusão.

## Envie, depois confirme

Envie com `skipPreflight: true` para trocar validação no lado do cliente por latência, depois confirme através de sua conexão RPC.

Sender retorna a assinatura imediatamente, o que não é prova de aterrissagem:

```typescript theme={"system"}
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;
}
```

Com `maxRetries: 0` você possui a política de tentativas: quando a confirmação expira, reconstrua com um novo blockhash e uma taxa reavaliada em vez de reenviar a transação obsoleta.

O throughput padrão é de 50 TPS. Planos profissionais podem [solicitar limites mais altos](https://www.helius.dev/contact).

## Opcional: evite atacantes sanduíche

Adicione `?mev-protect=true` ao URL do endpoint para evitar validadores estatisticamente ligados a ataques sanduíche. O corpo da solicitação permanece inalterado, e isso funciona em ambos os níveis:

```text theme={"system"}
http://ewr-sender.helius-rpc.com/fast?mev-protect=true
```

Veja [MEV Protect](/docs/pt-BR/sending-transactions/mev-protect) para os trade-offs. Para execução atômica de multitransações (até 4 transações, tudo ou nada), use [`sendBundle`](/docs/pt-BR/sending-transactions/sender-max#pacotes) no mesmo endpoint.

## Guias relacionados

<CardGroup cols={2}>
  <Card title="Visão geral do Sender" icon="paper-plane" href="/docs/pt-BR/sending-transactions/sender">
    Níveis, endpoints, contas de gorjeta e limites de taxa em detalhes
  </Card>

  <Card title="Comércio em Pré-confirmações" icon="stopwatch" href="/docs/pt-BR/pre-confirmations/guides/trade-on-preconfirmations">
    Combine o caminho de envio mais rápido com o sinal de transação mais precoce
  </Card>
</CardGroup>