Dokumentasi SolanaPanduan

Alur Transaksi Lengkap Kora

Terakhir Diperbarui: 2025-10-31

Apa yang Akan Anda Bangun

Dalam Panduan Mulai Cepat, Anda telah mempelajari cara menyiapkan Kora RPC dan melakukan pemanggilan dasar. Sekarang kita akan membangun sistem transaksi tanpa gas yang lengkap untuk mendemonstrasikan kemampuan penuh Kora. Di akhir panduan ini, Anda akan mengimplementasikan alur transaksi yang:

  • Membuat beberapa instruksi transfer (token SPL dan SOL)
  • Mendapatkan instruksi pembayaran dari Kora untuk penutupan biaya
  • Menandatangani transaksi dengan kunci pengguna sementara Kora menangani biaya gas
  • Mengirimkan transaksi yang telah ditandatangani sepenuhnya ke jaringan Solana

Hasil akhirnya akan menjadi sistem transaksi tanpa gas yang berfungsi:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

KORA GASLESS TRANSACTION DEMO

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━



[1/6] Initializing clients

  → Kora RPC: http://localhost:8080/

  → Solana RPC: http://127.0.0.1:8899



[2/6] Setting up keypairs

  → Sender: BYJVBqQ2xV9GECc84FeoPQy2DpgoonZQFQu97MMWTbBc

  → Destination: C8MC9E6nf9Am1rVqdDedDavm53uCJMiSwarEko1aXmny

  → Kora signer address: 3Z1Ef7YaxK8oUMoi6exf7wYZjZKWJJsrzJXSt1c3qrDE



[3/6] Creating demonstration instructions

  → Payment token: 9BgeTKqmFsPVnfYscfM6NvsgmZxei7XfdciShQ6D3bxJ

  ✓ Token transfer instruction created

  ✓ SOL transfer instruction created

  ✓ Memo instruction created

  → Total: 3 instructions



[4/6] Estimating Kora fee and assembling payment instruction

  → Fee payer: 3Z1Ef7Ya...

  → Blockhash: 7HZUaMqV...

  ✓ Estimate transaction built

  ✓ Payment instruction received from Kora



[5/6] Creating and signing final transaction (with payment)

  ✓ Final transaction built with payment

  ✓ Transaction signed by user



[6/6] Signing transaction with Kora and sending to Solana cluster

  ✓ Transaction co-signed by Kora

  ✓ Transaction submitted to network

  ⏳ Awaiting confirmation...



━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

SUCCESS: Transaction confirmed on Solana

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━



Transaction signature:

41hmwmkMfHR5mmhG9sNkjiakwHxpmr1H3Gi3bBL8v5PbsRrH7FhpUT8acHaf2mrPKNVD894dSYXfjp6LfAbVpcCE



View on explorer:

https://explorer.solana.com/tx/41hmwmkMfHR5mmhG9sNkjiakwHxpmr1H3Gi3bBL8v5PbsRrH7FhpUT8acHaf2mrPKNVD894dSYXfjp6LfAbVpcCE?cluster=custom&customUrl=http%3A%2F%2Flocalhost%3A8899

Mari kita bangun langkah demi langkah!

Prasyarat

Sebelum memulai tutorial ini, pastikan Anda memiliki:

Alur Transaksi Kora

Kora memungkinkan transaksi tanpa gas dengan bertindak sebagai pembayar biaya untuk transaksi pengguna Anda. Alur transaksi tanpa gas terdiri dari langkah-langkah utama berikut:

  1. Pembuatan Transaksi - Membangun transaksi yang diinginkan pengguna (transfer, pemanggilan program, dll.)
  2. Estimasi Biaya - Membuat transaksi estimasi untuk menghitung biaya yang diperlukan
  3. Instruksi Pembayaran - Mendapatkan instruksi pembayaran dari Kora yang menentukan jumlah biaya
  4. Penandatanganan Pengguna - Pengguna menandatangani transaksi termasuk instruksi pembayaran
  5. Penandatanganan Bersama Kora - Kora memvalidasi pembayaran dan menandatangani bersama sebagai pembayar biaya
  6. Pengiriman - Mengirimkan transaksi yang telah ditandatangani sepenuhnya ke Solana

*Catatan: Kora dapat dikonfigurasi untuk tidak memerlukan pembayaran, tetapi kami akan menggunakannya untuk mendemonstrasikan alur lengkap.

Pengaturan Proyek

Pertimbangan Server Kora

  • Daftar Izin Token - Hanya token yang dikonfigurasi dalam kora.toml yang dapat digunakan untuk pembayaran - pastikan token yang didefinisikan dalam .env Anda disertakan dalam kora.toml daftar izin.
  • Pembatasan Program - Transaksi hanya dapat berinteraksi dengan program yang masuk daftar putih. Kami telah menyiapkan kora.toml untuk mengizinkan interaksi dengan System Program, Token Program, Compute Unit Program, dan program Memo.

Pengaturan Klien

Panduan ini mengasumsikan Anda telah menyelesaikan Mulai Cepat dan telah menyiapkan proyek demo. Jika belum, silakan selesaikan terlebih dahulu.

Navigasi ke direktori klien demo Anda:

cd kora/examples/getting-started/demo/client

Catatan: File demo terletak di repositori GitHub karena memerlukan pengaturan pengembangan lengkap.

Implementasi

Sebelum kita mulai menjalankan demo, mari kita telusuri implementasi demo lengkap langkah demi langkah:

Impor dan Konfigurasi

Demo kami dimulai dengan impor dan konfigurasi yang diperlukan:

import { KoraClient } from "@solana/kora";

import {

  createKeyPairSignerFromBytes,

  getBase58Encoder,

  createNoopSigner,

  address,

  getBase64EncodedWireTransaction,

  partiallySignTransactionMessageWithSigners,

  Blockhash,

  Base64EncodedWireTransaction,

  partiallySignTransaction,

  TransactionVersion,

  Instruction,

  KeyPairSigner,

  Rpc,

  SolanaRpcApi,

  createSolanaRpc,

  createSolanaRpcSubscriptions,

  pipe,

  createTransactionMessage,

  setTransactionMessageFeePayerSigner,

  setTransactionMessageLifetimeUsingBlockhash,

  MicroLamports,

  appendTransactionMessageInstructions

} from "@solana/kit";

import { getAddMemoInstruction } from "@solana-program/memo";

import { createRecentSignatureConfirmationPromiseFactory } from "@solana/transaction-confirmation";

import {

  updateOrAppendSetComputeUnitLimitInstruction,

  updateOrAppendSetComputeUnitPriceInstruction

} from "@solana-program/compute-budget";

import dotenv from "dotenv";

import path from "path";



dotenv.config({ path: path.join(process.cwd(), "..", ".env") });



const CONFIG = {

  computeUnitLimit: 200_000,

  computeUnitPrice: 1_000_000n as MicroLamports,

  solanaRpcUrl: "http://127.0.0.1:8899",

  solanaWsUrl: "ws://127.0.0.1:8900",

  koraRpcUrl: "http://localhost:8080/"

};

Kami mengimpor Kora Client dari Kora SDK dan beberapa tipe/pembantu dari pustaka Solana Kit untuk membangun transaksi.

Kami juga membuat objek konfigurasi global yang mendefinisikan:

  • Anggaran Komputasi - Unit dan harga untuk prioritas transaksi
  • Versi Transaksi - Menggunakan V0 untuk dukungan tabel pencarian alamat
  • Endpoint RPC - Server RPC Solana dan Kora lokal

Biarkan nilai default ini untuk saat ini--setelah demo, Anda dapat bereksperimen dengan nilai yang berbeda untuk melihat bagaimana pengaruhnya terhadap alur transaksi.

Fungsi Utilitas

Demo ini mencakup fungsi pembantu untuk memuat keypair dari variabel lingkungan:

async function getEnvKeyPair(envKey: string) {

  if (!process.env[envKey]) {

    throw new Error(`Environment variable ${envKey} is not set`);

  }

  const base58Encoder = getBase58Encoder();

  const b58SecretEncoded = base58Encoder.encode(process.env[envKey]);

  return await createKeyPairSignerFromBytes(b58SecretEncoded);

}

Fungsi ini:

  • Membaca kunci privat yang dikodekan base58 dari variabel lingkungan
  • Mengkodekan string kunci privat ke array byte U8
  • Mengonversinya menjadi objek penanda tangan keypair

Langkah 1: Inisialisasi Klien

Pertama, kita menyiapkan koneksi ke Kora dan Solana:

async function initializeClients() {

  console.log("\n[1/6] Initializing clients");

  console.log("  → Kora RPC:", CONFIG.koraRpcUrl);

  console.log("  → Solana RPC:", CONFIG.solanaRpcUrl);



  const client = new KoraClient({

    rpcUrl: CONFIG.koraRpcUrl

    // apiKey: process.env.KORA_API_KEY, // Uncomment if authentication is enabled

    // hmacSecret: process.env.KORA_HMAC_SECRET, // Uncomment if HMAC is enabled

  });



  const rpc = createSolanaRpc(CONFIG.solanaRpcUrl);

  const rpcSubscriptions = createSolanaRpcSubscriptions(CONFIG.solanaWsUrl);



  const confirmTransaction = createRecentSignatureConfirmationPromiseFactory({

    rpc,

    rpcSubscriptions

  });



  return { client, rpc, confirmTransaction };

}

Fungsi ini:

  • Membuat instance klien Kora dengan memasukkan URL RPC Kora kita.
  • Membuat koneksi RPC Solana dengan dukungan subscription (kita akan menggunakannya untuk mengirim dan mengonfirmasi transaksi ke cluster Solana)
  • Menyiapkan utilitas konfirmasi transaksi

Catatan: File kora.toml kami tidak menyertakan autentikasi apa pun, jadi kita tidak perlu memasukkan kunci api atau rahasia hmac, tetapi kami telah meninggalkan kode yang dikomentari sebagai referensi.

Langkah 2: Menyiapkan Kunci

Muat keypair yang diperlukan dari variabel lingkungan dan ambil alamat penanda tangan Kora:

async function setupKeys(client: KoraClient) {

  console.log("\n[2/6] Setting up keypairs");



  const testSenderKeypair = await getEnvKeyPair("TEST_SENDER_KEYPAIR");

  const destinationKeypair = await getEnvKeyPair("DESTINATION_KEYPAIR");

  const { signer_address } = await client.getPayerSigner();



  console.log("  → Sender:", testSenderKeypair.address);

  console.log("  → Destination:", destinationKeypair.address);

  console.log("  → Kora signer address:", signer_address);



  return { testSenderKeypair, destinationKeypair, signer_address };

}

Di sini kita menggunakan fungsi getEnvKeyPair untuk memuat keypair dari variabel lingkungan. Keypair tersebut mewakili:

  • Pengirim - Pengguna yang memulai transaksi dan bertanggung jawab membayar node Kora dalam token pembayaran.
  • Tujuan - Penerima transfer.

Kami juga menggunakan metode getPayerSigner untuk mengambil alamat penanda tangan Kora. Ini adalah alamat yang akan digunakan untuk menandatangani transaksi dengan tanda tangan Kora. Penting bagi kita untuk mengambil penanda tangan yang valid dari node Kora dan menggunakannya secara konsisten di seluruh alur transaksi kita.

Langkah 3: Membuat Instruksi Demo

Selanjutnya, kita membuat serangkaian instruksi yang ingin dikirim oleh testSender kita ke jaringan. Kita akan menggunakan Kora Client untuk membuat beberapa instruksi ini dan library @solana/programs untuk membuat yang lainnya guna mendemonstrasikan cara menggunakan keduanya.

async function createInstructions(

  client: KoraClient,

  testSenderKeypair: KeyPairSigner,

  destinationKeypair: KeyPairSigner

) {

  console.log("\n[3/6] Creating demonstration instructions");



  const paymentToken = await client

    .getConfig()

    .then((config) => config.validation_config.allowed_spl_paid_tokens[0]);

  console.log("  → Payment token:", paymentToken);



  // Create token transfer (will initialize ATA if needed)

  const transferTokens = await client.transferTransaction({

    amount: 10_000_000, // 10 USDC (6 decimals)

    token: paymentToken,

    source: testSenderKeypair.address,

    destination: destinationKeypair.address

  });

  console.log("  ✓ Token transfer instruction created");



  // Create SOL transfer

  const transferSol = await client.transferTransaction({

    amount: 10_000_000, // 0.01 SOL (9 decimals)

    token: "11111111111111111111111111111111", // SOL mint address

    source: testSenderKeypair.address,

    destination: destinationKeypair.address

  });

  console.log("  ✓ SOL transfer instruction created");



  // Add memo instruction

  const memoInstruction = getAddMemoInstruction({

    memo: "Hello, Kora!"

  });

  console.log("  ✓ Memo instruction created");



  const instructions = [

    ...transferTokens.instructions,

    ...transferSol.instructions,

    memoInstruction

  ];



  console.log(`  → Total: ${instructions.length} instructions`);

  return { instructions, paymentToken };

}

Ada cukup banyak hal yang terjadi di sini, jadi mari kita telusuri langkah demi langkah:

  1. Kita menggunakan getConfig untuk mendapatkan token pembayaran dari konfigurasi Kora. Karena kita telah menyiapkan server, kita tahu hanya ada satu token di allowlist, jadi kita bisa mengaksesnya langsung di posisi pertama (config.validation_config.allowed_spl_paid_tokens[0]).
  2. Kita membuat instruksi transfer token menggunakan metode transferTransaction dari Kora Client. Ini adalah metode pembantu yang memudahkan pembuatan instruksi transfer token.
  3. Kita membuat instruksi transfer SOL menggunakan metode transferTransaction dari Kora Client. Kami menyertakan ini untuk menunjukkan cara membuat transfer SOL menggunakan Kora Client--perhatikan bahwa kita menggunakan Native SOL mint 11111111111111111111111111111111 untuk menunjukkan bahwa kita ingin mentransfer SOL alih-alih transfer token SPL.
  4. Kita menambahkan instruksi memo menggunakan fungsi getAddMemoInstruction dari library @solana/programs.
  5. Kita menggabungkan semua instruksi ke dalam satu array. Kita akan menggunakan array ini untuk membuat transaksi estimasi kita di langkah berikutnya.

Langkah 4: Dapatkan Instruksi Pembayaran dari Kora

Buat transaksi yang akan menghasilkan instruksi pembayaran ke Kora sebagai imbalan atas biaya yang diperlukan untuk mengeksekusi transaksi.

async function getPaymentInstruction(

  client: KoraClient,

  instructions: Instruction[],

  testSenderKeypair: KeyPairSigner,

  paymentToken: string

): Promise<{ paymentInstruction: Instruction }> {

  console.log("\n[4/6] Estimating Kora fee and assembling payment instruction");



  const { signer_address } = await client.getPayerSigner();

  const noopSigner = createNoopSigner(address(signer_address));

  const latestBlockhash = await client.getBlockhash();



  console.log("  → Fee payer:", signer_address.slice(0, 8) + "...");

  console.log("  → Blockhash:", latestBlockhash.blockhash.slice(0, 8) + "...");



  // Create estimate transaction to get payment instruction

  const estimateTransaction = pipe(

    createTransactionMessage({ version: 0 }),

    (tx) => setTransactionMessageFeePayerSigner(noopSigner, tx),

    (tx) =>

      setTransactionMessageLifetimeUsingBlockhash(

        {

          blockhash: latestBlockhash.blockhash as Blockhash,

          lastValidBlockHeight: 0n

        },

        tx

      ),

    (tx) => appendTransactionMessageInstructions(instructions, tx),

    (tx) =>

      updateOrAppendSetComputeUnitPriceInstruction(CONFIG.computeUnitPrice, tx),

    (tx) =>

      updateOrAppendSetComputeUnitLimitInstruction(CONFIG.computeUnitLimit, tx)

  );



  const signedEstimateTransaction =

    await partiallySignTransactionMessageWithSigners(estimateTransaction);

  const base64EncodedWireTransaction = getBase64EncodedWireTransaction(

    signedEstimateTransaction

  );

  console.log("  ✓ Estimate transaction built");



  // Get payment instruction from Kora

  const paymentInstruction = await client.getPaymentInstruction({

    transaction: base64EncodedWireTransaction,

    fee_token: paymentToken,

    source_wallet: testSenderKeypair.address

  });

  console.log("  ✓ Payment instruction received from Kora");



  return { paymentInstruction: paymentInstruction.payment_instruction };

}

SDK Kora memiliki metode pembantu getPaymentInstruction yang akan menghitung biaya yang tepat yang diperlukan untuk transaksi dan membuat instruksi transfer pembayaran. Berikut cara kita menggunakannya:

  1. Pertama, kita membuat estimateTransaction yang mencakup instruksi yang kita inginkan--transaksi ini akan disimulasikan di server Kora untuk memperkirakan biaya yang diperlukan untuk transaksi tersebut.
  2. Kemudian kita menandatangani sebagian transaksi untuk mendapatkan string wire yang dikodekan base64.
  3. Kita meneruskan transaksi wire yang dikodekan base64 ke metode getPaymentInstruction dengan token pembayaran dan sumber pembayaran. Ini akan mengembalikan objek Instruction yang dapat kita tambahkan ke transaksi kita.

Konsep kunci di sini:

  • Blockhash Valid - Kita menggunakan metode getBlockhash untuk mendapatkan blockhash yang valid untuk transaksi kita. Ini diperlukan untuk memperkirakan transaksi karena akan mensimulasikan transaksi di server.
  • Noop Signer - Penandatangan placeholder yang digunakan saat membangun transaksi sebelum Kora menandatangani. Ini memungkinkan kita menentukan pembayar biaya dalam transaksi kita sebelum kita memiliki tanda tangan Kora. Untuk informasi lebih lanjut tentang Noop Signers, lihat Dokumentasi Solana Kit.
  • Penandatanganan Sebagian - Untuk mendapatkan transaksi kita sebagai string wire yang dikodekan base64 (kita memerlukan ini untuk mengirim transaksi melalui Kora RPC), kita perlu menandatangani sebagian transaksi. Untuk informasi lebih lanjut tentang Partial Signers, lihat Dokumentasi Solana Kit.

Langkah 5: Buat dan Tandatangani Transaksi Akhir

Sekarang setelah kita memiliki instruksi pembayaran, kita dapat membuat transaksi akhir yang mencakup instruksi asli kita dan instruksi pembayaran.

async function getFinalTransaction(

  client: KoraClient,

  paymentInstruction: Instruction,

  testSenderKeypair: KeyPairSigner,

  instructions: Instruction[],

  signer_address: string

): Promise<Base64EncodedWireTransaction> {

  console.log("\n[5/6] Creating and signing final transaction (with payment)");

  const noopSigner = createNoopSigner(address(signer_address));



  // Build final transaction with payment instruction

  const newBlockhash = await client.getBlockhash();

  const fullTransaction = pipe(

    createTransactionMessage({ version: 0 }),

    (tx) => setTransactionMessageFeePayerSigner(noopSigner, tx),

    (tx) =>

      setTransactionMessageLifetimeUsingBlockhash(

        {

          blockhash: newBlockhash.blockhash as Blockhash,

          lastValidBlockHeight: 0n

        },

        tx

      ),

    (tx) =>

      appendTransactionMessageInstructions(

        [...instructions, paymentInstruction],

        tx

      ),

    (tx) =>

      updateOrAppendSetComputeUnitPriceInstruction(CONFIG.computeUnitPrice, tx),

    (tx) =>

      updateOrAppendSetComputeUnitLimitInstruction(CONFIG.computeUnitLimit, tx)

  );

  console.log("  ✓ Final transaction built with payment");



  // Sign with user keypair

  const signedFullTransaction =

    await partiallySignTransactionMessageWithSigners(fullTransaction);

  const userSignedTransaction = await partiallySignTransaction(

    [testSenderKeypair.keyPair],

    signedFullTransaction

  );

  const base64EncodedWireFullTransaction = getBase64EncodedWireTransaction(

    userSignedTransaction

  );

  console.log("  ✓ Transaction signed by user");



  return base64EncodedWireFullTransaction;

}

Kita menggunakan fungsi pipe yang sama untuk merakit transaksi kita. Transaksi akhir kita mencakup:

  • Instruksi asli kita
  • Instruksi pembayaran
  • Blockhash baru
  • Noop signer yang sama seperti yang digunakan sebelumnya untuk membangun transaksi perkiraan

Kemudian kami memanggil fungsi partiallySignTransactionMessageWithSigners yang sama untuk mendapatkan string wire yang dikodekan base64 dari transaksi. Namun kali ini, kami juga menjalankan partiallySignTransaction untuk menandatangani transaksi dengan testSenderKeypair kami. Meskipun node Kora kami yang membayar biaya jaringan, testSender kami tetap perlu menandatangani untuk mengotorisasi pembayaran token dan instruksi transfer lainnya yang telah kami buat. Untuk node Kora yang tidak memerlukan pembayaran, instruksi tertentu mungkin tidak memerlukan langkah penandatanganan ini. Terakhir, kami mengembalikan string wire yang dikodekan base64 dari transaksi.

Langkah 6: Kirim Transaksi

Terakhir, kami perlu mendapatkan node Kora untuk menandatangani transaksi sehingga kami dapat mengirim transaksi yang telah ditandatangani sepenuhnya ke jaringan. Kami melakukan ini dengan memanggil metode signTransaction pada klien Kora.

async function submitTransaction(

  client: KoraClient,

  rpc: Rpc<SolanaRpcApi>,

  confirmTransaction: ReturnType<

    typeof createRecentSignatureConfirmationPromiseFactory

  >,

  signedTransaction: Base64EncodedWireTransaction,

  signer_address: string

) {

  console.log(

    "\n[6/6] Signing transaction with Kora and sending to Solana cluster"

  );



  // Get Kora's signature

  const { signed_transaction } = await client.signTransaction({

    transaction: signedTransaction,

    signer_key: signer_address

  });

  console.log("  ✓ Transaction co-signed by Kora");



  // Submit to Solana network

  const signature = await rpc

    .sendTransaction(signed_transaction as Base64EncodedWireTransaction, {

      encoding: "base64"

    })

    .send();

  console.log("  ✓ Transaction submitted to network");



  console.log("  ⏳ Awaiting confirmation...");

  await confirmTransaction({

    commitment: "confirmed",

    signature,

    abortSignal: new AbortController().signal

  });



  console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

  console.log("SUCCESS: Transaction confirmed on Solana");

  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

  console.log("\nTransaction signature:");

  console.log(signature);



  return signature;

}

Di sini kami melakukan tiga hal:

  1. Kami memanggil metode signTransaction pada klien Kora untuk mendapatkan node Kora menandatangani transaksi. Node akan memeriksa transaksi untuk memastikan pembayaran mencukupi dan kemudian menandatangani transaksi. Catatan: beberapa node Kora mungkin mengaktifkan signTransaction yang tidak memerlukan pembayaran. Anda dapat memeriksa konfigurasi node Anda untuk melihat apakah ini diaktifkan dengan menjalankan getConfig().
  2. Kami mengirim transaksi yang telah ditandatangani sepenuhnya ke jaringan Solana menggunakan klien RPC Solana.
  3. Kami menunggu transaksi dikonfirmasi di jaringan.

Fungsi Orkestrasi Utama

Fungsi utama mengikat semuanya bersama-sama dan memanggil setiap fungsi kami secara berurutan:

async function main() {

  console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

  console.log("KORA GASLESS TRANSACTION DEMO");

  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");



  try {

    // Step 1: Initialize clients

    const { client, rpc, confirmTransaction } = await initializeClients();



    // Step 2: Setup keys

    const { testSenderKeypair, destinationKeypair, signer_address } =

      await setupKeys(client);



    // Step 3: Create demo instructions

    const { instructions, paymentToken } = await createInstructions(

      client,

      testSenderKeypair,

      destinationKeypair

    );



    // Step 4: Get payment instruction from Kora

    const { paymentInstruction } = await getPaymentInstruction(

      client,

      instructions,

      testSenderKeypair,

      paymentToken

    );



    // Step 5: Create and partially sign final transaction

    const finalSignedTransaction = await getFinalTransaction(

      client,

      paymentInstruction,

      testSenderKeypair,

      instructions,

      signer_address

    );



    // Step 6: Get Kora's signature and submit to Solana cluster

    await submitTransaction(

      client,

      rpc,

      confirmTransaction,

      finalSignedTransaction,

      signer_address

    );

  } catch (error) {

    console.error("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    console.error("ERROR: Demo failed");

    console.error("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    console.error("\nDetails:", error);

    process.exit(1);

  }

}

Menjalankan Demo Lengkap

Untuk menjalankan demo transaksi tanpa biaya gas yang lengkap:

1. Pastikan Prasyarat Terpenuhi

Siapkan tiga jendela terminal:

  1. Jalankan validator pengujian lokal Anda:
solana-test-validator -r
  1. Jalankan server RPC Kora Anda (dari direktori examples/getting-started/demo/server):
kora rpc start --signers-config signers.toml
  1. Inisialisasi lingkungan Anda (dari direktori examples/getting-started/demo/client):
pnpm init-env

2. Jalankan Demo

# From the client directory

pnpm full-demo

3. Output yang Diharapkan

Anda akan melihat eksekusi langkah demi langkah dengan transaksi yang berhasil di akhir. Transaksi tersebut akan:

  • Mentransfer token dari pengirim ke tujuan
  • Mentransfer SOL dari pengirim ke tujuan
  • Menyertakan pesan memo "Hello, Kora!"
  • Membayar biaya kepada operator node Kora dalam token SPL yang Anda konfigurasi
  • Biaya gas transaksi dibayar oleh operator node Kora

Rekap: Memahami Alur Kerja

Mari kita tinjau apa yang terjadi dalam demonstrasi ini:

  1. Intensi Pengguna - Pengguna merakit transaksi yang mencakup berbagai instruksi yang ingin mereka jalankan.
  2. Estimasi Biaya - Kora menghitung biaya transaksi dalam token pilihan pengguna dan membuat instruksi pembayaran.
  3. Perakitan Transaksi - Pengguna merakit transaksi akhir yang mencakup instruksi yang dimaksudkan pengguna dan instruksi pembayaran Kora.
  4. Penandatanganan Transaksi - Pengguna menandatangani sebagian transaksi dengan keypair mereka dan mengirimkannya ke node Kora untuk ditandatangani setelah memverifikasi bahwa pembayaran mencukupi.
  5. Eksekusi Atomik - Pengguna mengirim transaksi ke Solana dan semuanya terjadi dalam satu transaksi:
    • Transfer yang dimaksudkan pengguna dieksekusi
    • Pembayaran biaya ditransfer ke Kora
    • Kora membayar biaya jaringan Solana dan menandatangani transaksi

Dan begitulah, pengguna tidak perlu memegang SOL untuk membayar biaya gas--mereka dapat membayar semuanya dengan token yang sudah mereka miliki!

Pemecahan Masalah

Masalah Umum

Validasi Transaksi Gagal

  • Verifikasi semua program ada dalam daftar putih di kora.toml
  • Periksa bahwa token mint ada di allowed_spl_paid_tokens
  • Pastikan transaksi tidak melebihi max_allowed_lamports

Pembuatan Instruksi Pembayaran Gagal

  • Konfirmasi transaksi estimasi memiliki blockhash yang baru untuk simulasi
  • Verifikasi alamat pembayaran Kora memiliki ATA yang sudah diinisialisasi
  • Periksa bahwa token pembayaran dikonfigurasi dengan benar

Verifikasi Tanda Tangan Gagal

  • Pastikan semua penandatangan yang diperlukan disertakan (Kora dan penandatangan lain yang diperlukan untuk pembayaran token atau instruksi lain yang termasuk dalam transaksi Anda)
  • Verifikasi transaksi tidak dimodifikasi setelah penandatanganan
  • Periksa bahwa keypair dimuat dengan benar

Penutup

Selamat! Anda telah berhasil mengimplementasikan alur transaksi tanpa biaya gas yang lengkap dengan Kora.

Kora memungkinkan untuk memberikan pengguna pengalaman Web3 yang mulus di mana mereka tidak perlu khawatir tentang biaya gas atau memegang SOL. Baik Anda membangun NeoBank, platform gaming, atau platform liquid staking, transaksi tanpa gas Kora menghilangkan hambatan utama untuk adopsi pengguna.

Tip: Untuk integrasi yang lebih sederhana, lihat Panduan Kit Client. API createKitKoraClient() menangani pengelolaan blockhash, estimasi biaya, injeksi instruksi pembayaran, dan pengiriman transaksi secara otomatis — mengurangi langkah-langkah manual yang ditunjukkan dalam panduan ini menjadi beberapa baris kode.

Sumber Daya Tambahan

Is this page helpful?

Sebelumnya

Integrasi Klien Kit

Berikutnya

Integrasi x402 dengan Kora

Daftar Isi

Edit Halaman

Dikelola oleh

© 2026 Yayasan Solana.
Semua hak dilindungi.
Solana
Terhubung