Mencapai Eksekusi Zero-Slot dengan Sender dan LaserStream

Pendahuluan

Semua orang ingin transaksi mereka masuk secepat mungkin. Namun, seiring makin canggihnya infrastruktur perdagangan Solana dan makin matangnya pasar on-chain, sekadar mengirim transaksi lalu berharap hasil terbaik tidak lagi cukup—kemacetan, persaingan, dan karakteristik jaringan mengubah “cepat” menjadi “sangat tidak dapat diandalkan.”

Tujuannya sederhana: saat sinyal muncul—harga melewati ambang tertentu, account diperbarui, atau program dipanggil—transaksi yang merespons sinyal tersebut harus masuk dalam slot yang sama. 

Itulah inti eksekusi zero-slot, ketika deteksi dan pengiriman berlangsung begitu mulus sehingga peluang dapat diraih sebelum lenyap dalam hitungan milidetik. 

Dalam praktiknya, hal ini semakin sulit dicapai karena membutuhkan penyerapan sinyal dengan latensi sangat rendah serta pengiriman yang andal dan deterministik.

Helius menyediakan keduanya.

Dengan menggabungkan LaserStream untuk deteksi peristiwa secepat kilat dan Sender untuk pengiriman transaksi yang dioptimalkan, Helius menghadirkan pipeline menyeluruh yang dirancang khusus untuk eksekusi zero-slot.

Tanpa infrastruktur tambal sulam, tanpa menebak-nebak, tanpa siklus yang terbuang—hanya sinyal tercepat dan jalur tercepat menuju leader, yang dirancang untuk memberi operasi perdagangan Anda keunggulan kompetitif.

LaserStream dan Sender: Alur Kerja Terpadu

Sender melengkapi LaserStream untuk menciptakan pipeline menyeluruh yang mulus bagi alur kerja perdagangan responsif di Solana. Dalam praktiknya,

1. Gunakan LaserStream untuk Mendengarkan Sinyal: Penyerapan pada tingkat shred dan pemfilteran canggih menghadirkan peristiwa on-chain secara real-time lebih cepat daripada pipeline lainnya.
2. Gunakan Helius Sender untuk Merespons Sinyal: Transaksi dikirim melalui SWQoS dan Jito secara bersamaan, dengan perutean global dan pengiriman yang mempertimbangkan validator untuk memaksimalkan penyertaan serta meminimalkan latensi.
3. Raih Keuntungan: Bersama-sama, layanan ini membuat peluang menguntungkan dapat diamankan dalam praktik, bukan sekadar teori.

Dengan Helius, developer mendapatkan stack yang terintegrasi secara vertikal dan dirancang khusus untuk kecepatan serta keandalan:

• Tidak perlu merangkai RPC pihak ketiga, relay, atau infrastruktur buatan sendiri.
• Perutean global, percobaan ulang otomatis, dan pengiriman yang mempertimbangkan validator sudah terintegrasi.
• Transparan dan adil—kami tidak secara aktif melakukan sandwich terhadap pengguna atau mengekstraksi MEV negatif dalam bentuk apa pun dari pengguna kami.

Helius telah menyediakan deteksi sinyal terbaik di kelasnya melalui LaserStream, jadi mengapa tidak memasangkannya dengan pengiriman transaksi terbaik di kelasnya melalui Sender? 

Bersama-sama, keduanya membentuk satu pipeline terpadu untuk alur kerja Solana yang mengutamakan setiap milidetik. Biarkan Helius menangani loop baca-tulis untuk menghasilkan hasil yang deterministik dan menguntungkan.

Jadi, seperti apa penerapannya dalam praktik?

Menemukan Sinyal yang Tepat

Peluang arbitrase dan likuidasi dapat lenyap dalam hitungan milidetik di Solana. Mendeteksi sinyal on-chain yang tepat secara cepat sangatlah penting. Di sini, “sinyal” berarti peristiwa real-time apa pun, seperti transfer token, pembaruan account, atau pemanggilan program, yang menghadirkan peluang perdagangan. Tanpa penyerapan berlatensi sangat rendah, keunggulan akan menguap sebelum dapat dimanfaatkan. Karena itu, streaming data yang andal dan berkecepatan tinggi sangat penting.

LaserStream adalah layanan streaming data Solana generasi berikutnya dari Helius yang memadukan kecepatan penyerapan tingkat shred dengan keandalan dan jangkauan layanan yang terdistribusi secara global, tanpa biaya atau kerumitan operasional untuk menjalankan beberapa node khusus.

Pemfilteran canggih LaserStream memungkinkan developer berfokus pada sinyal tertentu, seperti jenis transaksi, pembaruan account, serta streaming block secara umum. Untuk sinyal yang lebih awal lagi, Preprocessed Transactions melakukan streaming transaksi bertanda tangan yang didekode dari shred hingga 8 ms sebelum tingkat commitment processed, serta dipasangkan dengan Sender dengan cara yang sama persis.

Integrasinya mulus karena dirancang sebagai pengganti langsung Yellowstone gRPC dan mendukung beragam klien, termasuk Rust, Go, dan TypeScript. 

Namun, memiliki layanan streaming data terbaik di kelasnya baru menyelesaikan separuh tantangan, karena peluang yang dihadirkan sinyal terdiri dari dua bagian:

• Deteksi Peristiwa—mengetahui adanya sinyal potensial.
• Pengiriman Transaksi Reaktif—membuat, mengirim, dan memasukkan transaksi sebagai respons terhadap sinyal potensial.

LaserStream memberikan keunggulan dalam deteksi peristiwa sehingga pengiriman transaksi reaktif menjadi lebih efektif. Namun, LaserStream bukan layanan pengiriman transaksi, dan memasukkan transaksi secara efektif di Solana sayangnya tidak semudah menjalankan panggilan RPC sendTransaction sederhana.

Mengoptimalkan Alur Kerja Pengiriman Transaksi

Penyertaan transaksi adalah masalah optimasi dengan banyak variabel yang membutuhkan pemahaman mendalam tentang berbagai area dalam arsitektur Solana. Faktor seperti waktu kedatangan, keberhasilan simulasi, konflik penguncian account, biaya transaksi terkait, dan prioritas saling memengaruhi dalam menentukan kapan suatu transaksi dieksekusi secara on-chain. 

Mengabaikan salah satu faktor tersebut dalam alur kerja deteksi sinyal dan pembuatan transaksi dapat menimbulkan dampak merugikan, mengubah keunggulan kompetitif menjadi peluang yang terlewat. 

Sebagai contoh, meskipun seorang trader mendeteksi sinyal beberapa milidetik sebelum pesaingnya, keterlambatan kedatangan atau biaya yang tidak memadai dapat menyebabkan transaksi gagal secara on-chain satu slot terlambat, sehingga peluang menguntungkan berubah menjadi pendapatan yang hilang.

Memasukkan transaksi secara efektif membutuhkan alur kerja holistik yang memaksimalkan prioritas, meminimalkan latensi, dan mengantisipasi semua potensi kegagalan di seluruh stack. 

Untuk memasukkan transaksi secara efektif di Solana saat ini, developer perlu:

Menggunakan Staked Connections

Staked Connections memanfaatkan Stake-Weighted Quality of Service (SWQoS) Solana, yang memprioritaskan traffic dari validator dengan stake dan RPC pasangannya demi jangkauan leader serta kecepatan propagasi yang lebih baik. Developer sebaiknya merutekan transaksi melalui Staked Connections untuk meminimalkan kegagalan propagasi serta meningkatkan waktu kedatangan dan tingkat penyertaan tanpa hanya mengandalkan endpoint publik yang dapat mengalami kemacetan.

Menambahkan Priority Fee Dinamis

Priority fee membantu meningkatkan posisi transaksi dalam scheduler milik leader pada Banking Stage, tempat prio-graph (yaitu antrean prioritas yang memahami dependensi) mengurutkan eksekusi on-chain berdasarkan biaya per CU. Priority fee harus dihitung secara dinamis agar tidak menggunakan nilai statis yang menyebabkan pembayaran berlebih atau kurang dan menghambat penyertaan untuk mengakses state yang diperebutkan.

Mengoptimalkan Penggunaan CU

Compute Unit (CU) mengukur kebutuhan komputasi suatu transaksi. Melebihi anggaran yang diminta akan memicu kegagalan eksekusi, sedangkan permintaan berlebih meningkatkan biaya prioritas. Kecuali ditentukan lain, sebuah transaksi akan meminta 200.000 CU secara default. CU transaksi dapat dioptimalkan dengan menyimulasikan transaksi terlebih dahulu untuk memperkirakan konsumsinya, lalu meminta jumlah tertentu menggunakan instruksi SetComputeUnitLimit dari Compute Budget Program.

Menggunakan Tingkat Commitment yang Tepat untuk Mengambil Data

Tingkat commitment menentukan kedalaman konfirmasi untuk data yang diambil, seperti blockhash, yang harus tetap baru agar tidak kedaluwarsa dan untuk memastikan validitas transaksi. Menggunakan tingkat confirmed untuk panggilan getLatestBlockhash akan jauh lebih cepat daripada menggunakan finalized.

Melewati Pemeriksaan Preflight

Pemeriksaan preflight menyimulasikan transaksi pada node RPC sebelum pengiriman untuk memverifikasi tanda tangan, instruksi, dan eksekusi agar kesalahan dapat diketahui lebih awal. Namun, proses ini dapat menambahkan latensi hingga lebih dari 100 ms. Untuk alur kerja yang sensitif terhadap waktu dan ketika developer benar-benar yakin bahwa transaksi yang dikirim memiliki format yang benar, developer harus menetapkan parameter skipPreflight dalam metode RPC sendTransaction ke true.

Perlu diperhatikan bahwa Anda sangat disarankan membuat prototipe tanpa melewati pemeriksaan preflight guna memastikan transaksi diformat dengan benar dan berhasil masuk secara on-chain. Meskipun meningkatkan kecepatan, melewati pemeriksaan preflight berarti beroperasi tanpa visibilitas—transaksi dapat gagal karena berbagai alasan, dan tidak akan ada informasi tentang penyebab kegagalan jika pemeriksaan ini dilewati.

Menetapkan Parameter maxRetries ke Nol

Parameter maxRetries dalam metode sendTransaction mengaktifkan pengiriman ulang otomatis di sisi RPC jika terjadi kegagalan. Hal ini dapat menjadi tidak efisien, misalnya karena mengirim transaksi duplikat dengan blockhash yang sudah usang. Developer harus menetapkan maxRetries ke 0 untuk mengambil kembali kendali dan menerapkan percobaan ulang mereka sendiri di sisi klien yang menggunakan exponential backoff, memperbarui blockhash dan biaya saat menyiarkan ulang, serta memantau blockheight agar percobaan dapat diakhiri dengan baik.

Pertimbangkan untuk Menggunakan Jito

Tip Jito memungkinkan bundle off-chain melalui lelang MEV, yang menjamin penyertaan dan urutan transaksi untuk sebagian block. Ini ideal bagi trader atau pelaku arbitrase yang membutuhkan eksekusi di bagian teratas block atau atomisitas beberapa transaksi. Hal ini sangat bermanfaat untuk transaksi bernilai tinggi, sensitif terhadap waktu, atau transaksi apa pun yang bersaing memperebutkan state. Namun, lelang tersebut menambahkan penundaan yang justru dapat membuat waktu masuk transaksi lebih buruk daripada mengirim transaksi yang dioptimalkan dengan baik melalui Staked Connections. Developer perlu menggabungkan lelang di luar protokol ini dengan keandalan Staked Connections agar setiap jenis transaksi yang dibutuhkan dapat masuk secepat mungkin setiap saat.

Menerapkan praktik terbaik ini menghasilkan efek berlipat yang secara drastis mengurangi tingkat kegagalan dan meningkatkan keandalan transaksi untuk masuk. Namun, mengelolanya secara manual sekaligus mengikuti perkembangan protokol terbaru dan menyesuaikan alur kerja dengan perkembangan baru tersebut membutuhkan upaya engineering yang besar, termasuk penyesuaian terus-menerus, perubahan infrastruktur, dan penanganan kesalahan—upaya yang dapat dimanfaatkan dengan lebih baik di area lain.

Sender

Sender adalah layanan pengiriman transaksi Helius dengan latensi sangat rendah yang memanfaatkan SWQoS dan lelang off-chain Jito untuk penyertaan yang dioptimalkan bagi MEV, sekaligus menerapkan perutean geografis guna meminimalkan penundaan propagasi. 

Dengan mengirim transaksi secara bersamaan melalui Staked Connections dan rumah lelang Jito, Sender menyediakan dua jalur agar transaksi dapat masuk, meningkatkan keandalan, dan mengurangi waktu eksekusi tanpa mengonsumsi kredit tambahan.

Sender tersedia untuk semua paket dengan batas default 6 TPS yang dapat ditingkatkan berdasarkan permintaan. Layanan ini dibuat untuk trader, pencari MEV, dan aplikasi berfrekuensi tinggi yang membutuhkan hasil deterministik. Sender melengkapi LaserStream dengan menghadirkan alur kerja reaktif yang mulus untuk eksekusi zero-slot.

Cara Kerja Sender

Sender memproses transaksi seperti pemrosesan transaksi biasa—melalui permintaan POST JSON-RPC sederhana, dengan transaksi diserialisasi ke base64 dan dikirimkan ke salah satu endpoint-nya. 

Sender memiliki endpoint HTTPS global yang secara otomatis merutekan ke wilayah geografis terdekat, sehingga direkomendasikan untuk aplikasi frontend guna menghindari masalah CORS. 

Sender juga memiliki beberapa endpoint HTTP regional untuk latensi server-ke-server yang optimal (misalnya Salt Lake City, Tokyo, Frankfurt).

Yang terpenting, tidak ada autentikasi melalui API key—layanannya minimalis tanpa perantara antara penerimaan dan pengiriman transaksi, sehingga ideal untuk kasus penggunaan berlatensi sangat rendah. 

Agar dapat menggunakan Sender secara efektif, transaksi harus disiapkan sebagai berikut:

• Tip minimum sebesar 0,0002 SOL untuk Jito atau 0,000005 SOL (5.000 lamport) untuk pengiriman khusus SWQoS, yang dapat ditentukan dengan menambahkan ?swqos_only=true ke endpoint
• Parameter skipPreflight harus ditetapkan ke true—Sender dioptimalkan untuk memprioritaskan kecepatan dibandingkan validasi transaksi
• Parameter maxRetries harus ditetapkan ke 0—percobaan ulang menambah latensi
• Priority fee harus ditambahkan untuk meningkatkan prioritas transaksi di Banking Stage milik leader

Semua transaksi yang dikirim melalui Sender harus menyertakan tip dan priority fee. 

Tip diperlukan untuk memungkinkan akses ke infrastruktur Jito dan penyertaan transaksi berbasis lelang. Priority fee memberi tahu leader (yaitu validator yang bertanggung jawab memproses transaksi) tentang kesediaan membayar pemrosesan prioritas. Ini memberikan manfaat ganda: tip memberi akses ke infrastruktur lelang Jito, sedangkan priority fee meningkatkan prioritas transaksi. Keduanya bekerja untuk memaksimalkan penyertaan transaksi.

Kami menyarankan untuk mengambil tip secara dinamis menggunakan API batas bawah tip Jito (misalnya, ambil persentil ke-75 lalu tambahkan sedikit buffer) dan priority fee menggunakan Priority Fee API Helius. 

Setelah dikirimkan, Sender akan mendistribusikan transaksi secara paralel melalui SWQoS dan Jito untuk memaksimalkan penyertaan transaksi tanpa biaya tambahan. 

Kami juga menyarankan untuk menghangatkan koneksi selama periode tidak aktif (yaitu >1 menit) dengan melakukan ping ke /ping (yaitu https://sender.helius-rpc.com/ping) guna menghindari cold start. Kami juga menyarankan untuk mengikuti praktik terbaik pengiriman transaksi agar penyertaan transaksi semakin optimal. 

Cara Memulai

Berikut cara mulai berdagang dengan LaserStream dan Sender:

Menggunakan LaserStream

LaserStream menawarkan pengalaman developer yang sama seperti bekerja dengan gRPC. Cukup ubah endpoint dan API key agar mengarah ke LaserStream, lalu langsung nikmati semua manfaat yang ditawarkan LaserStream.

Untuk kode yang sudah ada, migrasinya cukup dilakukan dengan:

// Before: Using standard Yellowstone gRPC
const connection = new GeyserConnection(
  "your-current-endpoint.com",
  { token: "your-current-token" }
);

// After: Using LaserStream (just change the endpoint and token)
const connection = new GeyserConnection(
  "https://laserstream-mainnet-ewr.helius-rpc.com", // Choose the closest region to you
  { token: "your-helius-api-key" }
);

Kami menyarankan untuk menggunakan salah satu klien LaserStream guna menyederhanakan proses pengembangan.

Sebagai contoh, membuka subscription cukup dilakukan dengan:

// Using the dedicated LaserStream SDK
import { subscribe, CommitmentLevel, LaserstreamConfig } from 'helius-laserstream';

const config = {
  apiKey: "your-helius-api-key",
  endpoint: "https://laserstream-mainnet-ewr.helius-rpc.com" // Choose the closest region to you
};

// The SDK automatically handles:
// - Connection management
// - Reconnection with backoff
// - Historical replay after disconnects
// - Subscription management
await subscribe(config, subscriptionRequest, handleData, handleError);

Coba LaserStream Secara Gratis

Ingin menguji LaserStream sebelum bermigrasi? Dapatkan uji coba gratis untuk mengukur latensi LaserStream, membandingkannya dengan solusi streaming alternatif, dan mengevaluasinya untuk kasus penggunaan spesifik Anda.

Menggunakan Sender

Helius Sender tersedia untuk semua pengguna dan tidak mengonsumsi kredit tambahan—tidak memerlukan paket berbayar atau akses khusus.

Untuk memulai, buat account di Helius Dashboard. Kemudian, buka bagian API Key dan salin key yang tersedia. Key ini diperlukan untuk mengambil blockhash dan mengonfirmasi transaksi karena Sender hanya menangani pengiriman transaksi.

Berikut adalah transfer SOL sederhana menggunakan Sender. Contoh ini menyertakan semua komponen yang diperlukan—tip, priority fee, dan melewati pemeriksaan preflight.

import { pipe } from "@solana/kit";
import {
  createSolanaRpc,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  lamports,
  getBase64EncodedWireTransaction,
} from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";

(async () => {
  const HELIUS_API_KEY = "your_api_key";
  const PRIV_KEY_B58 = "your_private_key";
  const RECIPIENT = "recipient_address";
  const TIP_ACCOUNTS = [
    "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
    "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
    "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
    "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
    "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
    "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
    "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
    "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
    "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
    "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
  ];

  // Load signer from base58 private key
  const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(PRIV_KEY_B58));

  // Init RPC and fetch blockhash
  const rpc = createSolanaRpc(`https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`);
  const { value: blockhash } = await rpc.getLatestBlockhash().send();

  // Build and sign transaction
  const tx = pipe(
    createTransactionMessage({ version: 0 }),
    (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
    (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
    (m) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 1000 }), m),
    (m) => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 200_000 }), m),
    (m) =>
      appendTransactionMessageInstruction(
        getTransferSolInstruction({
          source: ownerSigner,
          destination: RECIPIENT,
          amount: lamports(1_000_000n), // 0.001 SOL
        }),
        m
      ),
    (m) =>
      appendTransactionMessageInstruction(
        getTransferSolInstruction({
          source: ownerSigner,
          destination: TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)],
          amount: lamports(200_000n), // 0.0002 SOL
        }),
        m
      )
  );

  const signedTx = await signTransactionMessageWithSigners(tx);
  const base64Tx = getBase64EncodedWireTransaction(signedTx);

  // Send via Sender
  const res = await fetch("https://sender.helius-rpc.com/fast", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: Date.now().toString(),
      method: "sendTransaction",
      params: [
        base64Tx,
        { encoding: "base64", skipPreflight: true, maxRetries: 0 },
      ],
    }),
  });

  const { result: sig, error } = await res.json();
  if (error) throw new Error(error.message);

  console.log("Transaction sent: ", sig);
  console.log(`Explorer: https://orb.helius.dev/tx/${sig}?cluster=mainnet`);
})();

Mengirim transaksi melalui Sender berjalan mulus dengan SDK Node.js kami. Metode `sendTransactionWithSender` menangani semua penghitungan compute unit dan biaya secara dinamis, termasuk tip Jito: 

import { createHelius } from "helius-sdk";
import { address, createKeyPairSignerFromBytes, lamports } from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import bs58 from "bs58";

(async () => {
  const apiKey = ""; // From Helius dashboard
  const helius = createHelius({ apiKey });

  try {
    const feePayerSigner = await createKeyPairSignerFromBytes(
      bs58.decode(process.env.FEEPAYER_SECRET ?? "")
    );

    const toPubkey = address("your_to_address");

    const transferIx = getTransferSolInstruction({
      amount: lamports(1_000_000n), // 0.001 SOL
      destination: toPubkey,
      source: feePayerSigner,
    });

    const sig = await helius.tx.sendTransactionWithSender({
      signers: [feePayerSigner],
      instructions: [transferIx],
      version: 0,
      commitment: "confirmed",
      minUnits: 1_000,
      bufferPct: 0.1,
      region: "US_EAST",
      swqosOnly: true,
      pollTimeoutMs: 60_000,
      pollIntervalMs: 2_000,
    });

    console.log("Confirmed signature:", sig);
    console.log(
      `Explorer link: https://orb.helius.dev/tx/${sig}?cluster=mainnet`
    );
  } catch (error) {
    console.error("Error:", error);
  }
})();

Proses ini juga dapat disederhanakan menggunakan SDK Rust kami melalui metode send_smart_transaction_with_sender().

Menggunakan LaserStream dan Sender

Kekuatan utama Helius berasal dari penggabungan LaserStream dan Sender ke dalam satu alur kerja. LaserStream menampilkan sinyal yang dapat ditindaklanjuti saat sinyal tersebut muncul, sedangkan Sender memastikan transaksi yang merespons sinyal itu masuk secepat mungkin.

Polanya sederhana:

• Berlangganan dengan LaserStream untuk mendengarkan perubahan account, pemanggilan program, atau transfer.
• Buat transaksi sebagai respons terhadap sinyal tertentu.
• Kirim transaksi melalui Sender untuk memastikan jalur tercepat dan paling andal menuju penyertaan.

Berikut contoh minimal yang menunjukkan alur kerja lengkap ini dalam praktik: 

import bs58 from "bs58";
import { subscribe, CommitmentLevel } from "helius-laserstream";
import {
  pipe,
  createSolanaRpc,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  getBase64EncodedWireTransaction,
  createKeyPairSignerFromBytes,
  lamports,
  address,
} from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";

const HELIUS_API_KEY = "your_api_key";
const LASERSTREAM_ENDPOINT = "https://laserstream-mainnet-ewr.helius-rpc.com"; // Pick the nearest region
const PRIV_KEY_B58 = "your_private_key";
const RECIPIENT = "recipient_address";
const TIP_ACCOUNTS = [
    "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
    "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
    "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
    "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
    "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
    "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
    "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
    "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
    "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
    "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
  ];

// Example: scope the stream to a program you care about
const PROGRAM_OWNER_TO_WATCH = "11111111111111111111111111111111";

(async () => {
  // Setup signer and fetch blockhash
  const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(PRIV_KEY_B58));
  const rpc = createSolanaRpc(`https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`);

  // Setup LaserStream config and request
  const config = {
    apiKey: HELIUS_API_KEY,
    endpoint: LASERSTREAM_ENDPOINT,
  };

  // We keep it scoped to a given program for less noise
  const request = {
    accounts: {
      watch: {
        account: [],
        owner: [PROGRAM_OWNER_TO_WATCH],
        filters: [],
      },
    },
    commitment: CommitmentLevel.PROCESSED, // Can also change to CONFIRMED for more reliability
    slots: {},
    transactions: {},
    transactionsStatus: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    accountsDataSlice: [],
  };

  // On signal, build and send a reactive transaction via Sender
  const handleData = async () => {
    // Fresh blockhash for lifetime
    const { value: blockhash } = await rpc.getLatestBlockhash().send();

    // Build the transaction with compute-budget ixs first, then user ixs
    const tx = pipe(
      createTransactionMessage({ version: 0 }),
      (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
      (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
      (m) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 100_000 }), m),
      (m) => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 200_000 }), m),
      (m) =>
        // In prod, this could be a buy / sell instruction
        appendTransactionMessageInstruction(
          getTransferSolInstruction({
            source: ownerSigner,
            destination: address(RECIPIENT),
            amount: lamports(1_000_000n), // 0.001 SOL
          }),
          m
        ),
      (m) =>
        appendTransactionMessageInstruction(
          getTransferSolInstruction({
            source: ownerSigner,
            destination: address(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
            amount: lamports(200_000n), // 0.0002 SOL tip
          }),
          m
        )
    );

    const signedTx = await signTransactionMessageWithSigners(tx);
    const base64Tx = getBase64EncodedWireTransaction(signedTx);

    // Send via Sender (i.e., skip preflight and no RPC-side retries)
    const res = await fetch("https://sender.helius-rpc.com/fast", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: Date.now().toString(),
        method: "sendTransaction",
        params: [base64Tx, { encoding: "base64", skipPreflight: true, maxRetries: 0 }],
      }),
    });

    const { result: sig, error } = await res.json();
    if (error) throw new Error(error.message);

    console.log("Reactive transaction sent: ", sig);
    console.log(`Explorer:  https://orb.helius.dev/tx/${sig}?cluster=mainnet`);
  };

  const handleError = console.error;

  // Start the stream (signals → reactive sends)
  const stream = await subscribe(config, request, handleData, handleError);
  console.log(`LaserStream subscription started (id: ${stream.id})`);
})();

Mengapa Helius

Helius menjadi pilihan utama untuk mengoptimalkan alur kerja transaksi di Solana berkat posisi kami sebagai validator jaringan terbesar berdasarkan stake. Karena itu, bandwidth dengan stake bukan masalah bagi kami. Hal ini secara efektif menghilangkan bottleneck atau kegagalan terkait penurunan prioritas transaksi maupun packet drop saat terjadi kemacetan, serta memberi transaksi Anda jalur langsung berprioritas tinggi menuju leader tanpa batasan. 

Dengan mengintegrasikan secara mendalam berbagai optimasi hardware dan software dengan bandwidth yang memiliki stake, Helius terus unggul sebagai penyedia terdepan dengan latensi slot rata-rata terendah—bukti keahlian vertikal kami di Solana. 

Komitmen kami terhadap Solana menempatkan kami di garis terdepan riset dan kontribusi terbaru. Sebagai contoh, temuan Chorus One tentang latensi transaksi menunjukkan bahwa SWQoS sering kali dapat mengungguli Jito dalam mengurangi waktu hingga penyertaan, terutama bagi pengguna dengan latensi p95 lebih dari 40 detik. Sender secara cerdas merutekan melalui SWQoS dan Jito secara bersamaan untuk memastikan keandalan maksimum bagi semua jenis transaksi. 

Pada akhirnya, memiliki stake yang besar dan merutekan transaksi melalui Staked Connections adalah faktor terpenting yang perlu dipertimbangkan untuk mengurangi waktu hingga penyertaan.

Lebih Cepat

LaserStream mengurangi latensi dan ketidakpastian. Makin cepat sinyal tiba, makin mudah hasilnya diprediksi. Saat digabungkan dengan Sender, transaksi yang dikirim sebagai respons terhadap sinyal memberikan keyakinan operasional yang lebih tinggi, keputusan yang lebih cerdas, dan keandalan yang lebih baik. Pipeline terpadu ini tidak hanya mengoptimalkan kecepatan secara terpisah—pipeline ini mengoptimalkan keyakinan.

Dengan LaserStream, developer tahu bahwa mereka menggunakan layanan streaming data terbaik di pasar. Dengan Sender, mereka dapat yakin bahwa transaksi dirutekan melalui jalur tercepat dan paling andal menuju block leader. 

Bersama-sama, keduanya menciptakan efek berlipat:

• Latensi E2E lebih rendah: Dari deteksi peristiwa hingga penyertaan transaksi, setiap langkah dipangkas menjadi hitungan milidetik
• Tingkat keberhasilan lebih tinggi: Transaksi masuk di tempat dan waktu yang semestinya, sehingga peluang dapat diraih alih-alih terlewat
• Beban engineering lebih rendah: Anda dapat lebih berfokus pada produk, strategi, dan penyempurnaan algoritme perdagangan daripada mengelola serta menyesuaikan node khusus untuk mengoptimalkan pengiriman transaksi
• Eksekusi zero-slot: LaserStream menampilkan notifikasi saat transaksi sedang dieksekusi untuk slot tertentu, bukan setelah slot selesai, yang berarti transaksi yang dikirim sebagai respons terhadap notifikasi dapat masuk dalam slot yang sama 

Dalam praktiknya, ini berarti trader meraih lebih banyak arbitrase, likuidator memenangkan lebih banyak lelang, dan aplikasi berfrekuensi tinggi menghadirkan pengalaman pengguna yang lebih mulus. Eksekusi zero-slot bukan sekadar cita-cita teoretis yang ditakdirkan, melainkan alur kerja berulang yang hanya dapat dicapai dengan Helius.

Kunjungi Helius Dashboard dan mulai hari ini.