> ## 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.
# Cara Mengirim Transaksi Solana
> Panduan langkah demi langkah untuk membangun alur kerja pengiriman transaksi Solana yang andal dan siap produksi. Pelajari pengoptimalan komputasi, biaya prioritas, dan strategi konfirmasi.
Ini adalah jalur pengiriman transaksi **dasar** — ditagih per pengiriman dan paling sesuai ketika
keandalan lebih penting daripada kecepatan mentah (pembayaran, dompet, aplikasi). Jika Anda
melakukan perdagangan dan memerlukan latensi terendah, gunakan [Helius
Sender](/docs/id/sending-transactions/sender).
Membangun logika pengiriman transaksi Anda sendiri adalah cara terbaik untuk memastikan performa, kontrol, dan keandalan maksimum bagi aplikasi Anda. Meskipun [Helius SDK](/docs/id/sdks) menyediakan pembungkus praktis untuk memulai, memahami dan menerapkan alur kerja manual ini sangat disarankan untuk sistem produksi.
Panduan ini akan memandu Anda melalui langkah-langkah yang diperlukan untuk membangun solusi Anda sendiri.
### Alur Kerja Manual
Mengirim transaksi secara manual mencakup langkah-langkah berikut:
Susun instruksi Anda dan tanda tangani transaksi agar dapat disimulasikan.
Simulasikan transaksi untuk menentukan CU yang diperlukan secara tepat, lalu tambahkan sedikit cadangan.
Dapatkan estimasi biaya dari Helius Priority Fee API dan tambahkan ke transaksi Anda.
Kirim transaksi akhir dan terapkan strategi polling yang andal untuk menangani konfirmasi.
Helius SDK bersifat sumber terbuka. Anda dapat melihat kode yang mendasari metode `sendSmartTransaction` dalam [TypeScript SDK](https://github.com/helius-labs/helius-sdk) dan [Rust SDK](https://github.com/helius-labs/helius-rust-sdk) kami untuk melihat implementasi siap produksi dari alur kerja ini.
### 1. Bangun Transaksi Awal
Pertama, kumpulkan semua instruksi yang ingin Anda sertakan dalam transaksi. Kemudian, buat objek `Transaction` atau `VersionedTransaction`. Anda juga perlu mengambil blockhash terbaru.
Contoh ini menyiapkan transaksi berversi. Pada tahap ini, Anda juga harus menandatanganinya agar transaksi dapat disimulasikan pada langkah berikutnya.
```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. Optimalkan Penggunaan Unit Komputasi (CU)
Untuk menghindari pemborosan biaya atau kegagalan transaksi, Anda harus menetapkan batas unit komputasi (CU) setepat mungkin. Anda dapat melakukannya dengan menyimulasikan transaksi menggunakan metode RPC [`simulateTransaction`](/docs/id/api-reference/rpc/http/simulatetransaction).
Praktik terbaiknya adalah terlebih dahulu melakukan simulasi dengan batas CU yang tinggi untuk memastikan simulasi itu sendiri berhasil, lalu menggunakan `unitsConsumed` dari respons untuk menetapkan batas aktual Anda.
```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,
});
```
Sekarang Anda memiliki instruksi yang menetapkan batas komputasi secara tepat. Anda akan menambahkannya ke transaksi akhir.
### 3. Tetapkan Biaya Prioritas yang Tepat
Berikutnya, tentukan biaya prioritas optimal yang akan ditambahkan ke transaksi Anda. Menggunakan [Priority Fee API](/docs/id/priority-fee-api) Helius adalah cara terbaik untuk mendapatkan estimasi waktu nyata berdasarkan kondisi jaringan saat ini.
Anda perlu memanggil metode RPC `getPriorityFeeEstimate`. Untuk peluang penyertaan tertinggi melalui koneksi dengan stake milik Helius, gunakan opsi `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. Bangun, Kirim, dan Konfirmasikan
Sekarang, susun transaksi akhir dengan instruksi anggaran komputasi yang baru, kirimkan, lalu terapkan mekanisme polling yang andal untuk mengonfirmasi bahwa transaksi telah masuk.
Jangan mengandalkan logika percobaan ulang default milik penyedia RPC (`maxRetries` dalam [`sendTransaction`](/docs/id/api-reference/rpc/http/sendtransaction)). Meskipun koneksi dengan stake milik Helius meneruskan transaksi Anda langsung kepada leader, transaksi tersebut masih dapat terlewat. Anda harus menerapkan logika penyiaran ulang sendiri untuk memastikan konfirmasi yang andal.
Pola yang umum adalah mengirim ulang transaksi yang sama secara berkala hingga blockhash kedaluwarsa. **Hanya tanda tangani ulang transaksi jika Anda juga mengambil blockhash baru.** Penandatanganan ulang dengan blockhash yang sama dapat menyebabkan transaksi duplikat dikonfirmasi.
```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));
}
```
Contoh ini menyediakan perulangan polling dasar. Aplikasi siap produksi memerlukan logika yang lebih canggih, termasuk penanganan berbagai status konfirmasi dan potensi batas waktu.
## Lindungi dari serangan sandwich
Untuk mengarahkan transaksi Anda agar tidak melewati validator yang secara statistik terkait dengan serangan sandwich, tambahkan parameter kueri `mev-protect=true` ke URL RPC Anda — tanpa mengubah logika transaksi:
```
https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY&mev-protect=true
```
Pelajari cara kerja MEV Protect, metode yang didukungnya, dan komprominya.
## Dapatkan rabat dari transaksi Anda
Anda dapat memilih untuk memperoleh bagian dari MEV yang dihasilkan transaksi Anda, yang dibayarkan secara otomatis dalam SOL — tanpa mengubah logika transaksi.
Tambahkan satu parameter ke pemanggilan `sendTransaction` Anda untuk mulai memperoleh rabat SOL.
## Metode Terkait
Kirim transaksi yang telah ditandatangani ke jaringan
Simulasikan transaksi untuk memperkirakan unit komputasi
Periksa status konfirmasi transaksi
Dapatkan blockhash terbaru untuk penandatanganan transaksi
Dapatkan tinggi blok saat ini untuk pemeriksaan kedaluwarsa