> ## 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.
# Cómo enviar transacciones de Solana
> Guía paso a paso para crear flujos de envío de transacciones de Solana sólidos y listos para producción. Aprende sobre la optimización del cómputo, las comisiones de prioridad y las estrategias de confirmación.
Esta es la ruta **básica** para enviar transacciones. Se factura por envío y es
la mejor opción cuando la fiabilidad importa más que la velocidad bruta (pagos,
billeteras, aplicaciones). Si haces trading y necesitas la menor latencia, usa [Helius
Sender](/docs/es/sending-transactions/sender) en su lugar.
Crear tu propia lógica de envío de transacciones es la mejor manera de garantizar el máximo rendimiento, control y fiabilidad para tu aplicación. Aunque el [SDK de Helius](/docs/es/sdks) proporciona un wrapper práctico para comenzar, es muy recomendable comprender e implementar este flujo de trabajo manual en sistemas de producción.
Esta guía te mostrará los pasos necesarios para crear tu propia solución.
### El flujo de trabajo manual
Enviar una transacción manualmente implica los siguientes pasos:
Reúne tus instrucciones y firma la transacción para poder simularla.
Simula la transacción para determinar con precisión las CU necesarias y agrega un pequeño margen.
Obtén una estimación de la comisión mediante la API de comisiones de prioridad de Helius y agrégala a tu transacción.
Envía la transacción final e implementa una estrategia sólida de sondeo para gestionar la confirmación.
Los SDK de Helius son de código abierto. Puedes consultar el código subyacente del método `sendSmartTransaction` en nuestro [SDK de TypeScript](https://github.com/helius-labs/helius-sdk) y [SDK de Rust](https://github.com/helius-labs/helius-rust-sdk) para ver una implementación de este flujo de trabajo lista para producción.
### 1. Crea la transacción inicial
Primero, reúne todas las instrucciones que quieras incluir en tu transacción. Luego, crea un objeto `Transaction` o `VersionedTransaction`. También tendrás que obtener un blockhash reciente.
Este ejemplo prepara una transacción versionada. En esta etapa, también debes firmarla para poder simularla en el siguiente paso.
```typescript theme={"system"}
import {
Connection,
Keypair,
TransactionMessage,
VersionedTransaction,
SystemProgram,
LAMPORTS_PER_SOL,
} from "@solana/web3.js";
const connection = new Connection("YOUR_RPC_URL");
const fromKeypair = Keypair.generate(); // Assume this is funded
const toPubkey = Keypair.generate().publicKey;
// 1. Build your instructions
const instructions = [
SystemProgram.transfer({
fromPubkey: fromKeypair.publicKey,
toPubkey: toPubkey,
lamports: 0.001 * LAMPORTS_PER_SOL,
}),
];
// 2. Get a recent blockhash
const { blockhash } = await connection.getLatestBlockhash();
// 3. Compile the transaction message
const messageV0 = new TransactionMessage({
payerKey: fromKeypair.publicKey,
recentBlockhash: blockhash,
instructions,
}).compileToV0Message();
// 4. Create and sign the transaction
const transaction = new VersionedTransaction(messageV0);
transaction.sign([fromKeypair]);
```
### 2. Optimiza el uso de unidades de cómputo (CU)
Para evitar desperdiciar comisiones o que falle tu transacción, debes establecer el límite de unidades de cómputo (CU) con la mayor precisión posible. Puedes hacerlo simulando la transacción mediante el método RPC [`simulateTransaction`](/docs/es/api-reference/rpc/http/simulatetransaction).
Una práctica recomendada es simular primero con un límite de CU alto para garantizar que la propia simulación se complete correctamente y, después, usar el valor `unitsConsumed` de la respuesta para establecer tu límite real.
```typescript theme={"system"}
import { ComputeBudgetProgram } from "@solana/web3.js";
// Create a test transaction with a high compute limit to ensure simulation succeeds
const testInstructions = [
ComputeBudgetProgram.setComputeUnitLimit({ units: 1_400_000 }),
...instructions, // Your original instructions
];
const testMessage = new TransactionMessage({
payerKey: fromKeypair.publicKey,
recentBlockhash: blockhash,
instructions: testInstructions,
}).compileToV0Message();
const testTransaction = new VersionedTransaction(testMessage);
testTransaction.sign([fromKeypair]);
// Simulate the transaction to get the exact CUs consumed
const { value: simulationResult } = await connection.simulateTransaction(testTransaction);
if (!simulationResult.unitsConsumed) {
throw new Error("Simulation failed to return unitsConsumed");
}
// Add a 10% buffer to the CU estimate
const computeUnitLimit = Math.ceil(simulationResult.unitsConsumed * 1.1);
// Create the instruction to set the CU limit
const setCuLimitInstruction = ComputeBudgetProgram.setComputeUnitLimit({
units: computeUnitLimit,
});
```
Ahora tienes una instrucción que establece con precisión el límite de cómputo. Agrégala a tu transacción final.
### 3. Establece la comisión de prioridad adecuada
A continuación, determina la comisión de prioridad óptima que debes agregar a tu transacción. Usar la [API de comisiones de prioridad](/docs/es/priority-fee-api) de Helius es la mejor manera de obtener una estimación en tiempo real basada en las condiciones actuales de la red.
Tendrás que llamar al método RPC `getPriorityFeeEstimate`. Para maximizar la probabilidad de inclusión mediante las conexiones con stake de Helius, usa la opción `recommended: true`.
```typescript theme={"system"}
// The transaction needs to be serialized and base58 encoded
const serializedTransaction = bs58.encode(transaction.serialize());
const response = await fetch("YOUR_RPC_URL", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: "1",
method: "getPriorityFeeEstimate",
params: [
{
// Pass the serialized transaction
transaction: serializedTransaction,
// Use 'recommended' for Helius's staked connections
options: { recommended: true },
},
],
}),
});
const data = await response.json();
if (!data.result || !data.result.priorityFeeEstimate) {
throw new Error("Failed to get priority fee estimate");
}
const priorityFeeEstimate = data.result.priorityFeeEstimate;
// Create the instruction to set the priority fee
const setPriorityFeeInstruction = ComputeBudgetProgram.setComputeUnitPrice({
microLamports: priorityFeeEstimate,
});
```
### 4. Crea, envía y confirma
Ahora, crea la transacción final con las nuevas instrucciones de presupuesto de cómputo, envíala e implementa un mecanismo sólido de sondeo para confirmar que se haya procesado.
No dependas de la lógica de reintentos predeterminada del proveedor RPC (`maxRetries` en [`sendTransaction`](/docs/es/api-reference/rpc/http/sendtransaction)). Aunque las conexiones con stake de Helius reenvían tu transacción directamente al líder, aún puede descartarse. Debes implementar tu propia lógica de retransmisión para garantizar una confirmación fiable.
Un patrón habitual consiste en volver a enviar periódicamente la misma transacción hasta que venza el blockhash. **Solo vuelve a firmar la transacción si también obtienes un nuevo blockhash.** Volver a firmarla con el mismo blockhash puede provocar que se confirmen transacciones duplicadas.
```typescript theme={"system"}
// 1. Add the new instructions to your original set
const finalInstructions = [
setCuLimitInstruction,
setPriorityFeeInstruction,
...instructions,
];
// 2. Re-build and re-sign the transaction with the final instructions
const { blockhash: latestBlockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
const finalMessage = new TransactionMessage({
payerKey: fromKeypair.publicKey,
recentBlockhash: latestBlockhash,
instructions: finalInstructions,
}).compileToV0Message();
const finalTransaction = new VersionedTransaction(finalMessage);
finalTransaction.sign([fromKeypair]);
// 3. Send the transaction
const signature = await connection.sendTransaction(finalTransaction, {
skipPreflight: true, // Optional: useful for bypassing client-side checks
});
// 4. Implement a polling loop to confirm the transaction
let confirmed = false;
while (!confirmed) {
const statuses = await connection.getSignatureStatuses([signature]);
const status = statuses && statuses.value && statuses.value[0];
if (status && (status.confirmationStatus === 'confirmed' || status.confirmationStatus === 'finalized')) {
console.log('Transaction confirmed!');
confirmed = true;
}
// Check if the blockhash has expired
const currentBlockHeight = await connection.getBlockHeight();
if (currentBlockHeight > lastValidBlockHeight) {
console.log('Blockhash expired, transaction failed.');
break;
}
// Wait for a short period before polling again
await new Promise(resolve => setTimeout(resolve, 2000));
}
```
Este ejemplo proporciona un bucle de sondeo básico. Una aplicación lista para producción requiere una lógica más sofisticada, que incluya la gestión de distintos estados de confirmación y posibles tiempos de espera.
## Protégete contra los ataques sándwich
Para evitar que tu transacción se dirija a validadores vinculados estadísticamente con ataques sándwich, agrega el parámetro de consulta `mev-protect=true` a tu URL de RPC. No necesitas cambiar la lógica de tu transacción:
```
https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY&mev-protect=true
```
Consulta cómo funciona MEV Protect, qué métodos admite y cuáles son sus desventajas.
## Obtén reembolsos por tus transacciones
Puedes participar para obtener una parte del MEV que generan tus transacciones, pagada automáticamente en SOL. No necesitas cambiar la lógica de tu transacción.
Agrega un parámetro a tus llamadas a `sendTransaction` para comenzar a obtener reembolsos en SOL.
## Métodos relacionados
Envía una transacción firmada a la red
Simula una transacción para estimar las unidades de cómputo
Comprueba el estado de confirmación de las transacciones
Obtén un blockhash reciente para firmar transacciones
Obtén la altura de bloque actual para comprobar el vencimiento