> ## 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.
# Como Enviar Transações Solana
> Guia passo a passo para construir fluxos de trabalho robustos e de nível de produção para envio de transações Solana. Aprenda sobre otimização de computação, taxas de prioridade e estratégias de confirmação.
Este é o caminho de envio de transações **básico** — cobrado por envio e melhor quando a
confiabilidade importa mais que a velocidade bruta (pagamentos, carteiras, apps). Se você estiver
negociando e precisar da menor latência, use o [Helius
Sender](/docs/pt-BR/sending-transactions/sender) em vez disso.
Construir sua própria lógica de envio de transações é a melhor maneira de garantir o máximo desempenho, controle e confiabilidade para sua aplicação. Embora o [Helius SDK](/docs/pt-BR/sdks) forneça uma camada conveniente para começar, entender e implementar este fluxo de trabalho manual é altamente recomendável para sistemas de produção.
Este guia irá orientá-lo pelas etapas necessárias para construir sua própria solução.
### O Fluxo de Trabalho Manual
Enviar uma transação manualmente envolve as seguintes etapas:
Monte suas instruções e assine a transação para que possa ser simulada.
Simule a transação para determinar as CUs precisas necessárias e adicione uma pequena margem.
Obtenha uma estimativa de taxa da Helius Priority Fee API e adicione à sua transação.
Envie a transação final e implemente uma estratégia de polling robusta para lidar com a confirmação.
Os SDKs da Helius são de código aberto. Você pode ver o código subjacente para o método `sendSmartTransaction` em nosso [Node.js SDK](https://github.com/helius-labs/helius-sdk) e [Rust SDK](https://github.com/helius-labs/helius-rust-sdk) para ver uma implementação de nível de produção deste fluxo de trabalho.
### 1. Construir a Transação Inicial
Primeiro, reúna todas as instruções que você deseja incluir em sua transação. Em seguida, crie um objeto `Transaction` ou `VersionedTransaction`. Você também precisará buscar um blockhash recente.
Este exemplo prepara uma transação com versão. Neste estágio, você também deve assiná-la para que possa ser simulada na próxima etapa.
```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. Otimizar o Uso de Unidades de Computação (CU)
Para evitar desperdiçar taxas ou ter sua transação falhando, você deve definir o limite de unidades de computação (CU) o mais precisamente possível. Você pode fazer isso simulando a transação usando o método RPC [`simulateTransaction`](/docs/pt-BR/api-reference/rpc/http/simulatetransaction).
É uma boa prática simular primeiro com um limite de CU alto para garantir que a simulação seja bem-sucedida, e então use o `unitsConsumed` da resposta para definir seu limite 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,
});
```
Agora você tem uma instrução que define o limite de computação precisamente. Você adicionará isso à sua transação final.
### 3. Definir a Taxa de Prioridade Correta
Em seguida, determine a taxa de prioridade ideal a ser adicionada à sua transação. Usar a Helius [Priority Fee API](/docs/pt-BR/priority-fee-api) é a melhor maneira de obter uma estimativa em tempo real com base nas condições atuais da rede.
Você precisará chamar o método RPC `getPriorityFeeEstimate`. Para a maior chance de inclusão via conexões apostas da Helius, use a opção `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. Construir, Enviar e Confirmar
Agora, monte a transação final com as novas instruções de orçamento de computação, envie-a e implemente um mecanismo de polling robusto para confirmar que foi processada.
Não confie na lógica de retry padrão do provedor RPC (`maxRetries` em [`sendTransaction`](/docs/pt-BR/api-reference/rpc/http/sendtransaction)). Embora as conexões apostas da Helius encaminhem sua transação diretamente para o líder, ela ainda pode ser descartada. Você deve implementar sua própria lógica de reenvio para confirmação confiável.
Um padrão comum é reenviar a mesma transação periodicamente até que o blockhash expire. **Reassine a transação apenas se você também estiver buscando um novo blockhash.** Reassinar com o mesmo blockhash pode levar a transações duplicadas sendo confirmadas.
```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 exemplo fornece um loop de polling básico. Uma aplicação de nível de produção requereria uma lógica mais sofisticada, incluindo o tratamento de diferentes status de confirmação e potenciais timeouts.
## Proteja-se contra ataques de sanduíche
Para desviar sua transação de validadores estatisticamente ligados a ataques de sanduíche, adicione o parâmetro de consulta `mev-protect=true` ao seu URL RPC — sem alterações na lógica da sua transação:
```
https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY&mev-protect=true
```
Veja como o MEV Protect funciona, quais métodos ele suporta e suas desvantagens.
## Ganhe reembolsos em suas transações
Você pode optar por ganhar uma parte do MEV que suas transações criam, pago automaticamente em SOL — sem alterações na lógica da sua transação.
Adicione um parâmetro às suas chamadas `sendTransaction` para começar a ganhar reembolsos em SOL.
## Métodos Relacionados
Envie uma transação assinada para a rede
Simule uma transação para estimar unidades de computação
Verifique o status de confirmação das transações
Obtenha um blockhash recente para assinatura de transação
Obtenha a altura atual do bloco para verificações de expiração