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,
  assertIsTransactionWithinSizeLimit,
} from '@solana/kit';
import {
  KaminoMarket,
  PROGRAM_ID,
  getFlashLoanInstructions,
  getAssociatedTokenAddress,
  getMedianSlotDurationInMsFromLastEpochs,
} 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, await getMedianSlotDurationInMsFromLastEpochs());

Configure Flash Loan Parameters

Set the token, the flash loan amount in lamports (1 USDC), and the wallet’s token account that receives it.

const usdcMint = address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
const usdcReserve = market!.getExistingFloatRateReserveByMint(usdcMint);

const flashLoanAmount = new Decimal(1_000_000);
const usdcAta = await getAssociatedTokenAddress(usdcMint, signer.address, usdcReserve.getLiquidityTokenProgram());

Build Flash Loan Instructions

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

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

borrowIxIndex: 0 says 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.

The flash repay takes the amount plus the reserve’s flash loan fee (reserve.state.config.fees.flashLoanFeeSf, 0.001% for USDC on the SOL/BTC Market). The wallet must already hold enough USDC in that token account to pay the fee, or the repay fails with insufficient funds.

Add Your Custom Instructions

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

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

const allInstructions = [flashBorrowIx, memoIx, flashRepayIx];

Build and Send Transaction

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

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

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

const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
assertIsTransactionWithinSizeLimit(signedTransaction);

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

console.log('Flash loan successful! Signature:', getSignatureFromTransaction(signedTransaction));

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.6.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.

Developers

Earn

Borrow

Multiply

Liquidity

Portfolio

Rewards

Oracle

Agentic Finance

Resources

Flash Loans

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

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