Solana-DokumentationAnleitungen

Vollständiger Kora-Transaktionsablauf

Zuletzt aktualisiert: 31.10.2025

Was Sie erstellen werden

Im Schnellstartleitfaden haben Sie gelernt, wie Sie Kora RPC einrichten und grundlegende Aufrufe durchführen. Jetzt erstellen wir ein vollständiges gebührenfreies Transaktionssystem, das die umfassenden Funktionen von Kora demonstriert. Am Ende dieses Leitfadens haben Sie einen Transaktionsablauf implementiert, der:

  • Mehrere Überweisungs Anweisungen erstellt (SPL-Token und SOL)
  • Zahlungs Anweisungen von Kora zur Fee-Deckung erhält
  • Transaktionen mit Benutzerschlüsseln signiert, während Kora die Gasgebühren übernimmt
  • Vollständig signierte Transaktionen an das Solana-Netzwerk übermittelt

Das Endergebnis wird ein funktionierendes gebührenfreies Transaktionssystem sein:

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

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

Lassen Sie uns es Schritt für Schritt erstellen!

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:

Kora-Transaktionsablauf

Kora ermöglicht gebührenfreie Transaktionen, indem es als Fee-Zahler für die Transaktionen Ihrer Benutzer fungiert. Der gebührenfreie Transaktionsablauf besteht aus folgenden Hauptschritten:

  1. Transaktionserstellung – Erstellen Sie die beabsichtigte Transaktion des Benutzers (Überweisungen, Programmaufrufe usw.)
  2. Fee-Schätzung – Erstellen Sie eine Schätztransaktion zur Berechnung der erforderlichen Gebühren
  3. Zahlungs Anweisungen – Erhalten Sie eine Zahlungs Anweisungen von Kora, die den Fee-Betrag angibt
  4. Benutzersignierung – Der Benutzer signiert die Transaktion einschließlich der Zahlungs Anweisungen
  5. Kora-Mitsignierung – Kora validiert die Zahlung und signiert als Fee-Zahler mit
  6. Übermittlung – Übermitteln Sie die vollständig signierte Transaktion an Solana

*Hinweis: Kora kann so konfiguriert werden, dass keine Zahlung erforderlich ist, aber wir werden es verwenden, um den vollständigen Ablauf zu demonstrieren.

Projekt-Setup

Überlegungen zum Kora-Server

  • Token-Zulassungsliste - Nur Token, die in kora.toml konfiguriert sind, können für die Zahlung verwendet werden - stellen Sie sicher, dass der in Ihrem .env definierte Token in Ihrer kora.toml Zulassungsliste enthalten ist.
  • Programmbeschränkungen - Transaktionen können nur mit zugelassenen Programmen interagieren. Wir haben die kora.toml vorkonfiguriert, um die Interaktion mit dem System Program, Token Program, Compute Unit Program und Memo-Programm zu ermöglichen.

Client-Setup

Diese Anleitung geht davon aus, dass Sie den Schnellstart abgeschlossen und das Demo- Projekt eingerichtet haben. Falls nicht, vervollständigen Sie dies bitte zuerst.

Navigieren Sie zu Ihrem Demo-Client-Verzeichnis:

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

Hinweis: Die Demo-Dateien befinden sich im GitHub-Repository, da sie eine vollständige Entwicklungsumgebung erfordern.

Implementierung

Bevor wir die Demo ausführen, gehen wir die vollständige Demo Scritt für Schritt durch:

Importe und Konfiguration

Unsere Demo beginnt mit den notwendigen Importen und der Konfiguration:

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/"

};

Wir importieren den Kora-Client aus dem Kora SDK sowie einige Typen/Helfer aus der Solana Kit-Bibliothek zum Erstellen von Transaktionen.

Wir erstellen außerdem ein globales Konfigurationsobjekt, das Folgendes definiert:

  • Compute Budget - Einheiten und Preis für die Transaktionspriorisierung
  • Transaktionsversion - Verwendung von V0 für Address Lookup Table-Unterstützung
  • RPC-Endpunkte - Lokale Solana- und Kora-RPC-Server

Belassen Sie diese Standardwerte vorerst – nach der Demo können Sie mit verschiedenen Werten experimentieren, um zu sehen, wie sie den Transaktionsablauf beeinflussen.

Hilfsfunktionen

Die Demo enthält eine Hilfsfunktion zum Laden von Keypairs aus Umgebungsvariablen:

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);

}

Diese Funktion:

  • Liest base58-kodierte private Schlüssel aus Umgebungsvariablen
  • Kodiert die Zeichenkette des privaten Schlüssels zu einem U8-Byte-Array
  • Konvertiert sie in Keypair-Signer-Objekte

Schritt 1: Clients initialisieren

Zunächst richten wir unsere Verbindung sowohl zu Kora als auch zu Solana ein:

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 };

}

Diese Funktion:

  • Erstellt eine Kora-Client-Instanz durch Übergabe unserer Kora-RPC-URL.
  • Stellt eine Solana-RPC-Verbindung mit Subscription-Unterstützung her (wir werden diese zum Senden und Bestätigen von Transaktionen an den Solana-Cluster verwenden)
  • Richtet Hilfsprogramme zur Transaktionsbestätigung ein

Hinweis: Unsere kora.toml Datei enthält keine Authentifizierung, daher müssen wir keinen API-Schlüssel oder HMAC-Secret übergeben, aber wir haben den auskommentierten Code als Referenz belassen.

Schritt 2: Schlüssel einrichten

Laden Sie die erforderlichen Keypairs aus den Umgebungsvariablen und rufen Sie die Kora-Signer-Adresse ab:

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 };

}

Hier verwenden wir unsere getEnvKeyPair-Funktion, um die Keypairs aus den Umgebungsvariablen zu laden. Die Keypairs repräsentieren:

  • Sender - Der Benutzer, der die Transaktion initiiert und für die Bezahlung des Kora-Knotens im Payment-Token verantwortlich ist.
  • Ziel - Der Empfänger der Überweisungen.

Wir verwenden auch die getPayerSigner-Methode, um die Kora-Signer-Adresse abzurufen. Dies ist die Adresse, die verwendet wird, um die Transaktion mit der Kora-Signatur zu signieren. Es ist wichtig, dass wir einen gültigen Signer vom Kora-Knoten abrufen und ihn konsistent während unseres gesamten Transaktionsablaufs verwenden.

Schritt 3: Demo- Anweisungen erstellen

Als Nächstes erstellen wir eine Reihe von Anweisungen, die unser testSender an das Netzwerk senden möchte. Wir werden den Kora-Client verwenden, um einige dieser Anweisungen zu erstellen, und die @solana/programs-Bibliothek für andere, um zu zeigen, wie beide verwendet werden.

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 };

}

Hier passiert einiges, also gehen wir es Schritt für Schritt durch:

  1. Wir verwenden getConfig, um das Zahlungstoken aus der Konfiguration von Kora zu erhalten. Da wir unseren Server eingerichtet haben, wissen wir, dass sich nur ein Token in der Zulassungsliste befindet, sodass wir direkt auf die 1. Position (config.validation_config.allowed_spl_paid_tokens[0]) zugreifen können.
  2. Wir erstellen eine Token-Transfer-Anweisung mit der transferTransaction-Methode des Kora-Clients. Dies ist eine Hilfsmethode, die das Erstellen einer Token-Transfer-Anweisung erleichtert.
  3. Wir erstellen eine SOL-Transfer-Anweisung mit der transferTransaction-Methode des Kora-Clients. Wir fügen dies hier ein, um zu zeigen, wie SOL-Transfers mit dem Kora-Client erstellt werden – beachten Sie, dass wir die Native SOL Mint 11111111111111111111111111111111 verwenden, um anzuzeigen, dass wir SOL anstelle eines SPL-Token-Transfers übertragen möchten.
  4. Wir fügen eine Memo-Anweisung mit der getAddMemoInstruction-Funktion der @solana/programs-Bibliothek hinzu.
  5. Wir kombinieren alle Anweisungen in einem einzigen Array. Wir werden dieses Array verwenden, um unsere Schätztransaktion im nächsten Schritt zu erstellen.

Schritt 4: Zahlungsanweisung von Kora erhalten

Erstellen Sie eine Transaktion, die eine Zahlungsanweisung an Kora generiert, im Austausch für die Fee, die zur Ausführung der Transaktion erforderlich sind.

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 };

}

Das Kora-SDK verfügt über eine Hilfsmethode getPaymentInstruction, die die exakten Fee für die Transaktion berechnet und eine Zahlungstransfer-Anweisung erstellt. So verwenden wir sie:

  1. Zuerst erstellen wir eine estimateTransaction, die unsere gewünschten Anweisungen enthält – diese Transaktion wird auf dem Kora-Server simuliert, um die erforderlichen Fee für die Transaktion zu schätzen.
  2. Anschließend signieren wir die Transaktion teilweise, um einen base64-codierten Wire-String zu erhalten.
  3. Wir übergeben unsere base64-codierte Wire-Transaktion an die getPaymentInstruction Methode mit dem Zahlungstoken und der Zahlungsquelle. Diese gibt ein Instruction Objekt zurück, das wir zu unserer Transaktion hinzufügen können.

Wichtige Konzepte hierbei:

  • Gültiger Blockhash - Wir verwenden die getBlockhash Methode, um einen gültigen Blockhash für unsere Transaktion zu erhalten. Dies ist erforderlich, um die Transaktion zu schätzen, da sie die Transaktion auf dem Server simuliert.
  • Noop Signer - Platzhalter-Signer, der beim Erstellen von Transaktionen verwendet wird, bevor Kora signiert. Dadurch können wir einen Fee-Zahler in unserer Transaktion angeben, bevor wir Koras Signatur haben. Weitere Informationen zu Noop Signers finden Sie in der Solana Kit Dokumentation.
  • Teilsignierung - Um unsere Transaktion als base64-codierten Wire-String zu erhalten (wir benötigen dies, um die Transaktion über den Kora RPC zu senden), müssen wir die Transaktion teilweise signieren. Weitere Informationen zu Partial Signers finden Sie in der Solana Kit Dokumentation.

Schritt 5: Finale Transaktion erstellen und signieren

Jetzt, da wir unsere Zahlungsanweisung haben, können wir eine finale Transaktion erstellen, die unsere ursprünglichen Anweisungen und die Zahlungsanweisung enthält.

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;

}

Wir verwenden dieselbe pipe Funktion, um unsere Transaktion zusammenzustellen. Unsere finale Transaktion umfasst:

  • Unsere ursprünglichen Anweisungen
  • Die Zahlungsanweisung
  • Einen frischen Blockhash
  • Denselben Noop Signer, der zuvor zum Erstellen der Schätztransaktion verwendet wurde

Wir rufen dann dieselbe partiallySignTransactionMessageWithSigners-Funktion auf, um einen base64-kodierten Wire-String der Transaktion zu erhalten. Dieses Mal führen wir jedoch auch partiallySignTransaction aus, um die Transaktion mit unserem testSenderKeypair zu signieren. Obwohl unser Kora-Knoten die Netzwerkgebühren bezahlt, muss unser testSender dennoch signieren, um die Token-Zahlung und die anderen von uns erstellten Transfer-Anweisungen zu autorisieren. Bei Kora-Knoten, die keine Zahlung erfordern, ist dieser Signierungsschritt bei bestimmten Anweisungen möglicherweise nicht erforderlich. Schließlich geben wir den base64-kodierten Wire-String der Transaktion zurück.

Schritt 6: Transaktion einreichen

Abschließend müssen wir den Kora-Knoten dazu bringen, die Transaktion zu signieren, damit wir eine vollständig signierte Transaktion an das Netzwerk senden können. Dies tun wir, indem wir die signTransaction-Methode auf dem Kora-Client aufrufen.

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;

}

Hier führen wir drei Dinge aus:

  1. Wir rufen die signTransaction-Methode auf dem Kora-Client auf, um den Kora-Knoten dazu zu bringen, die Transaktion zu signieren. Der Knoten wird die Transaktion überprüfen, um sicherzustellen, dass die Zahlung ausreichend ist, und dann die Transaktion signieren. Hinweis: Einige Kora-Knoten können signTransaction aktiviert haben, die keine Zahlung erfordern. Sie können die Konfiguration Ihres Knotens überprüfen, um zu sehen, ob dies aktiviert ist, indem Sie getConfig() ausführen.
  2. Wir senden die vollständig signierte Transaktion mithilfe des Solana-RPC-Clients an das Solana-Netzwerk.
  3. Wir warten darauf, dass die Transaktion im Netzwerk bestätigt wird.

Hauptorchestrierungsfunktion

Die Hauptfunktion fügt alles zusammen und ruft jede unserer Funktionen nacheinander auf:

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);

  }

}

Ausführung der vollständigen Demo

Um die vollständige Demo für gebührenfreie Transaktionen auszuführen:

1. Voraussetzungen sicherstellen

Richten Sie drei Terminalfenster ein:

  1. Starten Sie Ihren lokalen Test-Validator:
solana-test-validator -r
  1. Starten Sie Ihren Kora-RPC-Server (aus dem Verzeichnis examples/getting-started/demo/server):
kora rpc start --signers-config signers.toml
  1. Initialisieren Sie Ihre Umgebung (aus dem Verzeichnis examples/getting-started/demo/client):
pnpm init-env

2. Demo ausführen

# From the client directory

pnpm full-demo

3. Erwartete Ausgabe

Sie sollten die schrittweise Ausführung mit einer erfolgreichen Transaktion am Ende sehen. Die Transaktion wird:

  • Token vom Absender zum Empfänger übertragen
  • SOL vom Absender zum Empfänger übertragen
  • Eine "Hello, Kora!"-Memo-Nachricht enthalten
  • Fee in Ihrem konfigurierten SPL-Token an den Kora-Node-Betreiber zahlen
  • Transaktions-Gas-Gebühren vom Kora-Node-Betreiber bezahlen lassen

Zusammenfassung: Den Ablauf verstehen

Lassen Sie uns durchgehen, was in dieser Demonstration geschieht:

  1. Benutzerabsicht - Der Benutzer hat eine Transaktion zusammengestellt, die verschiedene Anweisungen enthielt, die er ausführen wollte.
  2. Fee-Schätzung - Kora hat die Transaktionskosten in dem vom Benutzer bevorzugten Token berechnet und eine Zahlungsanweisung erstellt.
  3. Transaktionszusammenstellung - Der Benutzer hat eine finale Transaktion zusammengestellt, die die beabsichtigten Anweisungen des Benutzers und die Kora-Zahlungsanweisung enthielt.
  4. Transaktionssignierung - Der Benutzer hat die Transaktion mit seinem Keypair teilweise signiert und zur Signierung an den Kora-Node gesendet, nachdem er überprüft hat, dass die Zahlung ausreichend war.
  5. Atomare Ausführung - Der Benutzer sendet die Transaktion an Solana und alles geschieht in einer einzigen Transaktion:
    • Die beabsichtigten Überweisungen des Benutzers werden ausgeführt
    • Die Zahlung für Fee wird an Kora übertragen
    • Kora zahlt die Solana-Netzwerkgebühren und signiert die Transaktion

Und so müssen Benutzer kein SOL halten, um Gas-Gebühren zu bezahlen – sie können alles mit den Token bezahlen, die sie bereits besitzen!

Fehlerbehebung

Häufige Probleme

Transaktionsvalidierung schlägt fehl

  • Überprüfen Sie, dass alle Programme in kora.toml auf der Whitelist stehen
  • Prüfen Sie, dass Token-Mints in allowed_spl_paid_tokens enthalten sind
  • Stellen Sie sicher, dass die Transaktion max_allowed_lamports nicht überschreitet

Generierung der Zahlungsanweisung schlägt fehl

  • Bestätigen Sie, dass die Schätztransaktion einen aktuellen Blockhash für die Simulation hat
  • Überprüfen Sie, dass die Zahlungsadresse von Kora initialisierte ATAs hat
  • Prüfen Sie, dass der Zahlungstoken ordnungsgemäß konfiguriert ist

Signaturverifizierung schlägt fehl

  • Stellen Sie sicher, dass alle erforderlichen Signer enthalten sind (Kora und alle Signer, die für Token-Zahlungen oder andere Anweisungen in Ihrer Transaktion erforderlich sind)
  • Überprüfen Sie, dass die Transaktion nach dem Signieren nicht verändert wurde
  • Prüfen Sie, dass Keypairs korrekt geladen wurden

Abschluss

Herzlichen Glückwunsch! Sie haben erfolgreich einen vollständigen gasfreien Transaktionsablauf mit Kora implementiert.

Kora ermöglicht es, Benutzern eine nahtlose Web3-Erfahrung zu bieten, bei der sie sich nie um Gas-Gebühren oder das Halten von SOL kümmern müssen. Egal, ob Sie eine NeoBank, Gaming-Plattform oder Liquid-Staking-Plattform entwickeln – Koras gasfreie Transaktionen beseitigen eine große Hürde für die Benutzerakzeptanz.

Tipp: Für eine einfachere Integration schauen Sie sich den Kit Client Guide an. Die createKitKoraClient()-API übernimmt automatisch das Blockhash-Management, die Fee-Schätzung, die Injektion von Zahlungsanweisungen und die Transaktionsübermittlung – und reduziert die in diesem Leitfaden gezeigten manuellen Schritte auf wenige Codezeilen.

Zusätzliche Ressourcen

Is this page helpful?

Vorherige

Kit-Client-Integration

Nächste

x402-Integration mit Kora

Inhaltsverzeichnis

Seite bearbeiten

Verwaltet von

© 2026 Solana Foundation.
Alle Rechte vorbehalten.
Solana
Verbinden Sie sich