Flash Loans

TypeScript
Rust

Import Dependencies

Import the required packages for Solana RPC communication, Kamino SDK operations, and Kit transaction building.

import {
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  address,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstructions,
  signTransactionMessageWithSigners,
  sendAndConfirmTransactionFactory,
  getSignatureFromTransaction,
  none,
  getProgramDerivedAddress,
  getAddressEncoder,
} from '@solana/kit';
import {
  KaminoMarket,
  PROGRAM_ID,
  getFlashLoanInstructions
} from '@kamino-finance/klend-sdk';
import { parseKeypairFile } from '@kamino-finance/klend-sdk/dist/utils/signer.js';
import { getAddMemoInstruction } from '@solana-program/memo';
import Decimal from 'decimal.js';

Setup Market and Signer

Load your keypair, initialize RPC connections, and load the Kamino market.

const KEYPAIR_FILE = '/path/to/your/keypair.json';
const signer = await parseKeypairFile(KEYPAIR_FILE);

const rpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
const rpcSubscriptions = createSolanaRpcSubscriptions('wss://api.mainnet-beta.solana.com');

const marketPubkey = address('7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF'); // SOL/BTC Market
const market = await KaminoMarket.load(rpc, marketPubkey, 400);

Configure Flash Loan Parameters

Set the token mint, flash loan amount, and derive the user’s token account address.

const usdcMint = address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'); // USDC
const usdcReserve = market!.getReserveByMint(usdcMint)!;

// Flash loan amount: 1 USDC
const flashLoanAmount = new Decimal(1_000_000);

// Derive user's USDC token account (ATA)
const ASSOCIATED_TOKEN_PROGRAM = address('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
const TOKEN_PROGRAM = usdcReserve.getLiquidityTokenProgram();

const addressEncoder = getAddressEncoder();
const [usdcAta] = await getProgramDerivedAddress({
  programAddress: ASSOCIATED_TOKEN_PROGRAM,
  seeds: [
    addressEncoder.encode(signer.address),
    addressEncoder.encode(TOKEN_PROGRAM),
    addressEncoder.encode(usdcMint)
  ],
});

Build Flash Loan Instructions

Generate the flash borrow and flash repay instructions using the Kamino SDK.

// Build flash loan instructions
const lendingMarketAuthority = await market!.getLendingMarketAuthority();

const { flashBorrowIx, flashRepayIx } = getFlashLoanInstructions({
  borrowIxIndex: 0,
  userTransferAuthority: signer,
  lendingMarketAuthority,
  lendingMarketAddress: market!.getAddress(),
  reserve: usdcReserve,
  amountLamports: flashLoanAmount,
  destinationAta: usdcAta,
  referrerAccount: none(),
  referrerTokenState: none(),
  programId: PROGRAM_ID,
});

The borrowIxIndex:0 parameter specifies that the flash borrow instruction is at index 0 in the transaction. The SDK uses this to validate that repayment occurs in the same transaction.

Add Your Custom Instructions

Create your custom instructions to execute with the borrowed funds. In this example, we use a simple memo instruction.

// Create memo instruction
const memoIx = getAddMemoInstruction({ memo: 'Hello Kamino' });

// Arrange instructions: flash borrow → your instructions → flash repay
const allInstructions = [flashBorrowIx, memoIx, flashRepayIx];

Replace the memo instruction with your actual business logic.

Build and Send Transaction

Build the transaction with a fresh blockhash and send it to the network.

// Get fresh blockhash
const { value: latestBlockhash } = await rpc
  .getLatestBlockhash({ commitment: 'finalized' })
  .send();

// Build transaction
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => appendTransactionMessageInstructions(allInstructions, tx),
  (tx) => setTransactionMessageFeePayerSigner(signer, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx)
);

const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);

const signature = getSignatureFromTransaction(signedTransaction);

await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(
  signedTransaction,
  {
    commitment: 'confirmed',
    skipPreflight: false,
  }
);

console.log(`Flash loan successful! Signature: ${signature}`);

Your flash loan transaction is complete! The borrowed funds were used for your operations and automatically repaid within the same atomic transaction.

Add Dependencies

[dependencies]
klend-interface = "0.1.0"
solana-pubkey = "2.1"
solana-instruction = "2.1"
solana-sdk = "~2.3"
solana-client = "~2.3"
spl-token = "7"
spl-associated-token-account = "6"

klend-interface is a lightweight Rust instruction builder that creates Vec<Instruction> with required refresh instructions prepended automatically.

Set Up RPC Client

use solana_client::rpc_client::RpcClient;
use solana_sdk::signer::keypair::read_keypair_file;
use solana_sdk::signer::Signer;

let rpc_client = RpcClient::new("https://api.mainnet-beta.solana.com");
let signer = read_keypair_file("/path/to/your/keypair.json")
    .expect("Failed to read keypair file");
let owner = signer.pubkey();

Fetch Reserve Data

use klend_interface::helpers;
use klend_interface::ReserveInfo;
use solana_pubkey::Pubkey;
use std::str::FromStr;

let reserve_pubkey = Pubkey::from_str("D6q6wuQSrifJKZYpR1M8R4YawnLDtDsMmWM1NbBmgJ59").unwrap();

let reserve_data = rpc_client.get_account(&reserve_pubkey)?;
let reserve = ReserveInfo::from_account_data(reserve_pubkey, &reserve_data.data)?;

Use ReserveInfo::from_account_data(pubkey, &data) to construct reserve info from raw RPC account bytes.

Derive Token Accounts

use spl_associated_token_account::get_associated_token_address;

let user_token_account = get_associated_token_address(&owner, &reserve.liquidity_mint);

Build Flash Loan Instructions

let (borrow_ix, repay_ix) = helpers::flash::flash_loan(
    owner,
    &reserve,
    user_token_account, // source for repayment
    user_token_account, // destination for borrowed funds
    1_000_000,          // 1 USDC (6 decimals)
    0,                  // borrow instruction index in the transaction
    None,               // no referrer
);

The borrow_instruction_index parameter specifies the position of the flash borrow instruction in the final transaction. Set to 0 if it is the first instruction.

Compose and Send Transaction

use solana_sdk::transaction::Transaction;
use solana_sdk::message::Message;

// Insert your custom instructions between borrow and repay
let your_custom_instructions = vec![/* your logic here */];

let mut all_instructions = vec![borrow_ix];
all_instructions.extend(your_custom_instructions);
all_instructions.push(repay_ix);

let message = Message::new(&all_instructions, Some(&owner));
let recent_blockhash = rpc_client.get_latest_blockhash()?;
let tx = Transaction::new(&[&signer], message, recent_blockhash);
let signature = rpc_client.send_and_confirm_transaction(&tx)?;
println!("Flash loan successful! Signature: {signature}");

The flash borrow and repay must be in the same transaction. You can insert any number of instructions between them.

​Flash Loans

​Import Dependencies

​Setup Market and Signer

​Configure Flash Loan Parameters

​Build Flash Loan Instructions

​Add Your Custom Instructions

​Build and Send Transaction

​Add Dependencies

​Set Up RPC Client

​Fetch Reserve Data

​Derive Token Accounts

​Build Flash Loan Instructions

​Compose and Send Transaction

Flash Loans

Import Dependencies

Setup Market and Signer

Configure Flash Loan Parameters

Build Flash Loan Instructions

Add Your Custom Instructions

Build and Send Transaction

Add Dependencies

Set Up RPC Client

Fetch Reserve Data

Derive Token Accounts

Build Flash Loan Instructions

Compose and Send Transaction