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

# Incluye operaciones con Sender

> Crea un bucle de envío de baja latencia con Helius Sender: endpoints regionales, conexiones precalentadas, tarifas de prioridad dinámicas, propinas y confirmación de inclusión con reintentos.

Sender envía simultáneamente tu transacción por todas las rutas de alta velocidad (Helius, Jito, Harmonic, Rakurai) y no consume créditos de API. Pagas por cada envío con una propina en SOL. Esta guía crea un bucle de envío para producción con conexiones precalentadas, tarifas con precios en tiempo real y confirmación con una política de reintentos.

## Elige tu nivel

[Sender Max](/docs/es/sending-transactions/sender-max) (propina mínima de 0.001 SOL) enruta por todas las rutas y entra en el búfer de propinas prioritarias, donde las propinas más altas se incluyen primero.

[Solo SWQOS](/docs/es/sending-transactions/sender-swqos-only) (0.000005 SOL) utiliza una única ruta rápida para optimizar los costos. Agrega `?swqos_only=true` a la URL del endpoint.

Las propinas entre los dos mínimos se procesan según el mejor esfuerzo a través de menos rutas, así que elige uno de los dos niveles.

## Elige tu endpoint

Los backends deben usar el endpoint HTTP regional más cercano a sus servidores (`http://ewr-sender.helius-rpc.com/fast`, `fra`, `slc`, `ams`, `lon`, `sg`, `tyo`).

Los navegadores deben usar el endpoint HTTPS global `https://sender.helius-rpc.com/fast`, que enruta automáticamente y evita problemas de CORS.

## Precalienta la conexión

Un protocolo de enlace TCP/TLS en frío agrega latencia al primer envío después de un período de inactividad.

Si tu sistema puede pasar más de unos 5 segundos entre envíos, mantén activa la conexión con el endpoint de 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);
```

## Crea la transacción

Cada transacción de Sender debe incluir tanto una transferencia de propina a una cuenta de propinas designada como un precio por unidad de cómputo. Sender rechaza las transacciones que no incluyan alguno de estos elementos.

Fijar la tarifa de prioridad en el código hace que pagues de más cuando el mercado está tranquilo y pierdas oportunidades cuando está activo. Por eso, calcúlala mediante la [API de tarifas de prioridad](/docs/es/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;
}
```

La propina determina qué rutas puede tomar tu transacción, y la tarifa de prioridad eleva su posición en la cola del validador. Juntas maximizan la probabilidad de inclusión.

## Envía y luego confirma

Envía con `skipPreflight: true` para reducir la latencia a cambio de omitir la validación del lado del cliente. Luego, confirma mediante tu conexión RPC.

Sender devuelve la firma de inmediato, pero esto no demuestra que la transacción se haya incluido:

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

Con `maxRetries: 0`, tú controlas la política de reintentos: cuando se agote el tiempo de espera de la confirmación, vuelve a crear la transacción con un hash de bloque nuevo y una tarifa recalculada, en lugar de reenviar la transacción obsoleta.

El rendimiento predeterminado es de 50 TPS. Los planes profesionales pueden [solicitar límites más altos](https://www.helius.dev/contact).

## Opcional: evita a los atacantes de tipo sándwich

Agrega `?mev-protect=true` a la URL del endpoint para evitar validadores vinculados estadísticamente con ataques de tipo sándwich. El cuerpo de la solicitud no cambia y funciona en ambos niveles:

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

Consulta [MEV Protect](/docs/es/sending-transactions/mev-protect) para conocer las ventajas y desventajas. Para ejecutar varias transacciones de forma atómica (hasta 4 transacciones, todas o ninguna), usa [`sendBundle`](/docs/es/sending-transactions/sender-max#paquetes) en el mismo endpoint.

## Guías relacionadas

<CardGroup cols={2}>
  <Card title="Sender overview" icon="paper-plane" href="/docs/es/sending-transactions/sender">
    Información completa sobre niveles, endpoints, cuentas de propinas y límites de tasa
  </Card>

  <Card title="Trade on Preconfirmations" icon="stopwatch" href="/docs/es/pre-confirmations/guides/trade-on-preconfirmations">
    Combina la ruta de envío más rápida con la señal de transacción más temprana
  </Card>
</CardGroup>