Kit Client Integration

Last Updated: 2026-03-09

What You'll Build

The Kit client (createKitKoraClient) is the recommended way to integrate Kora into Solana applications. It wraps Kora's fee abstraction into Kit's plugin architecture, giving you a client that automatically handles:

• Blockhash management
• Fee estimation and payment instruction injection
• Transaction signing via Kora
• Transaction submission and confirmation
• Compute budget optimization (simulation-based CU estimation)

This means you can use Kit program plugins like tokenProgram() and have Kora handle all the gas fee complexity behind the scenes.

Prerequisites

• Completed the Kora Quick Start Guide — running Kora server and local validator
• Familiarity with Solana Kit and its plugin system

Installation

pnpm add @solana/kora @solana/kit

Peer dependencies (@solana-program/token, @solana-program/compute-budget, @solana/kit-plugin-*) are auto-installed by most package managers. See Installation if you need to install them manually.

Creating the Client

createKitKoraClient composes multiple Kit plugins into a single client that satisfies ClientWithPayer, ClientWithTransactionPlanning, and ClientWithTransactionSending.

import { createKitKoraClient } from '@solana/kora';
import { address } from '@solana/kit';

const client = await createKitKoraClient({
  endpoint: 'http://localhost:8080',           // Kora RPC endpoint
  rpcUrl: 'http://127.0.0.1:8899',            // Solana RPC for CU estimation
  feeToken: address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'), // USDC mint
  feePayerWallet: userSigner,                  // TransactionSigner for fee payment
});

The feePayerWallet must be a TransactionSigner — this is the wallet that authorizes the SPL token fee payment to the Kora operator. The Kora operator handles the SOL network fees.

Configuration Options

Using with Kit Program Plugins

The Kit client is composable with Kit program plugins. For example, with tokenProgram():

import { createKitKoraClient } from '@solana/kora';
import { tokenProgram } from '@solana-program/token';
import { address } from '@solana/kit';

const koraClient = await createKitKoraClient({
  endpoint: 'http://localhost:8080',
  rpcUrl: 'http://127.0.0.1:8899',
  feeToken: address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
  feePayerWallet: userSigner,
});

// Compose with the token program plugin
const client = koraClient.use(tokenProgram());

// Use token program methods — Kora handles all fee abstraction
await client.token.instructions
  .transferToATA({
    source: userTokenAccount,
    destination: recipientAddress,
    amount: 1_000_000n, // 1 USDC
    authority: userSigner,
  })
  .sendTransaction();

Behind the scenes, the Kit client:

1. Plans the transaction with a Kora-managed blockhash and compute budget instructions
2. Estimates the fee and injects (or updates) the SPL payment instruction to the Kora operator
3. Partially signs the transaction with the user's wallet
4. Sends the transaction to Kora for co-signing and submission to Solana

Accessing Kora RPC Methods

The Kit client also exposes the full Kora API via the .kora namespace (from the koraPlugin):

// Get server configuration
const config = await client.kora.getConfig();

// Get supported fee tokens
const { tokens } = await client.kora.getSupportedTokens();

// Estimate fees for an arbitrary transaction
const estimate = await client.kora.estimateTransactionFee({
  transaction: base64EncodedTx,
  fee_token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
});

All .kora method responses use Kit-typed values (Address, Blockhash, Signature) instead of raw strings.

Token-2022 Support

To pay fees with a Token-2022 token, pass the tokenProgramId option:

import { TOKEN_2022_PROGRAM_ADDRESS } from '@solana-program/token-2022';

const client = await createKitKoraClient({
  endpoint: 'http://localhost:8080',
  rpcUrl: 'http://127.0.0.1:8899',
  feeToken: address('your-token-2022-mint'),
  feePayerWallet: userSigner,
  tokenProgramId: TOKEN_2022_PROGRAM_ADDRESS,
});

Compute Budget

By default, the Kit client simulates the transaction against the Solana RPC to determine the optimal compute unit limit. This results in tighter CU allocation and lower fees.

To override with a fixed value:

const client = await createKitKoraClient({
  // ...
  computeUnitLimit: 200_000,
  computeUnitPrice: 1_000_000n, // priority fee in micro-lamports
});

When to Use Each Client

Next Steps

• Full Transaction Flow — Lower-level walkthrough using KoraClient directly
• API Reference — All available RPC methods
• Kora Configuration — Server-side configuration options