Create a Vault

Create a Kamino vault with custom fee structures, deposit limits, and allocation strategies. The SDK manages vault initialization, metadata setup, and lookup table creation to optimize future transactions.

Creating a Vault

Initialize a new vault with custom configuration and prepare it for user deposits.

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,
} from '@solana/kit';
import {
  KaminoManager,
  KaminoVaultConfig,
  getMedianSlotDurationInMsFromLastEpochs,
} from '@kamino-finance/klend-sdk';
import { parseKeypairFile } from '@kamino-finance/klend-sdk/dist/utils/signer.js';
import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
import { Decimal } from 'decimal.js';

Load Admin Keypair and Initialize Manager

Load the admin keypair from file and initialize the Kamino manager with proper slot timing.

const KEYPAIR_FILE = '/path/to/your/keypair.json';

const adminSigner = await parseKeypairFile(KEYPAIR_FILE);

const rpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
const rpcSubscriptions = createSolanaRpcSubscriptions('wss://api.mainnet-beta.solana.com');
const slotDuration = await getMedianSlotDurationInMsFromLastEpochs();
const kaminoManager = new KaminoManager(rpc, slotDuration);

parseKeypairFile loads an existing keypair from a JSON file that will become the vault admin. The slot duration is used for accurate vault timing calculations.

Configure Vault Parameters

Create a vault configuration with fee structures, deposit limits, and allocation settings.

const kaminoVaultConfig = new KaminoVaultConfig({
  admin: adminSigner,
  tokenMint: address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
  tokenMintProgramId: TOKEN_PROGRAM_ADDRESS,
  performanceFeeRatePercentage: new Decimal(15.0),
  managementFeeRatePercentage: new Decimal(2.0),
  name: 'MyCustomVault',
  vaultTokenSymbol: 'USDC',
  vaultTokenName: 'MyCustomVaultToken',
  minDepositAmount: new Decimal(1000000),
  minWithdrawAmount: new Decimal(1000000),
  minInvestAmount: new Decimal(1000000),
  minInvestDelaySlots: 150,
  unallocatedWeight: 500,
  unallocatedTokensCap: new Decimal(2000000),
} as any);

The configuration sets fee percentages, minimum amounts for deposits/withdrawals, and allocation parameters. Fees are collected by the vault admin, and the unallocated weight determines how funds are distributed across lending markets.

Show Vault Configuration Parameters

Parameter	Type	Description
`admin`	`TransactionSigner`	Keypair that owns and manages the vault
`tokenMint`	`string`	SPL token mint address (e.g., USDC)
`tokenMintProgramId`	`Address`	Token program address (usually `TOKEN_PROGRAM_ADDRESS`)
`performanceFeeRatePercentage`	`Decimal`	Percentage of earned yield collected as fees
`managementFeeRatePercentage`	`Decimal`	Annual percentage fee on total assets
`name`	`string`	Internal vault identifier
`vaultTokenSymbol`	`string`	Token symbol for vault shares
`vaultTokenName`	`string`	Display name for vault shares
`minDepositAmount`	`Decimal`	Minimum tokens required for deposit (in base units)
`minWithdrawAmount`	`Decimal`	Minimum tokens that can be withdrawn (in base units)
`minInvestAmount`	`Decimal`	Minimum amount before vault invests in lending markets
`minInvestDelaySlots`	`number`	Minimum slots to wait before investing deposits
`unallocatedWeight`	`number`	Percentage of funds kept liquid (not lent out)
`unallocatedTokensCap`	`Decimal`	Maximum tokens to keep unallocated (in base units)

Generate Vault Creation Instructions

Pass the vault configuration to the Kamino manager to generate all required initialization instructions.

const { vault: vaultSigner, initVaultIxs: instructions } = await kaminoManager.createVaultIxs(kaminoVaultConfig);

const allInstructions = [
  ...instructions.createAtaIfNeededIxs,
  ...instructions.initVaultIxs,
  instructions.createLUTIx,
  instructions.initSharesMetadataIx,
];

The createVaultIxs method takes the vault configuration from Step 3 and returns a vault signer (the vault’s address and keypair) plus instruction bundles for creating associated token accounts, initializing the vault, creating a lookup table (LUT), and initializing share token metadata.

Build and Sign Transaction

Use Kit’s functional pipe pattern to build and sign the transaction with a fresh blockhash.

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

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

const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);

Kit’s pipe function enables functional composition of transaction building steps. The signTransactionMessageWithSigners automatically handles all required signers including the vault keypair embedded in the instructions.

Send and Confirm Transaction

Send the transaction with built-in confirmation. Once confirmed, the vault is fully created and functional. The vault address is available from vaultSigner.address.

const signature = getSignatureFromTransaction(signedTransaction);

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

console.log('Vault creation successful! Vault ID:', vaultSigner.address);

setImmediate(async () => {
  try {
    await new Promise((resolve) => setTimeout(resolve, 2000));

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

    const lutMessage = pipe(
      createTransactionMessage({ version: 0 }),
      (tx) => setTransactionMessageFeePayerSigner(adminSigner, tx),
      (tx) => setTransactionMessageLifetimeUsingBlockhash(lutBlockhash, tx),
      (tx) => appendTransactionMessageInstructions(instructions.populateLUTIxs, tx)
    );

    const signedLutTx = await signTransactionMessageWithSigners(lutMessage);
    const lutSignature = getSignatureFromTransaction(signedLutTx);

    await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signedLutTx, {
      commitment: 'confirmed',
      skipPreflight: true,
    });
  } catch (error) {
    // LUT population failure doesn't affect vault functionality
  }
});

Show setImmediate alernatives

Background LUT Population

Lookup tables (LUTs) store frequently-used account addresses to reduce transaction size and optimize future vault operations.

The LUT is populated asynchronously after vault creation using setImmediate(), a Node.js utility that runs code in the background without blocking execution.

The 2-second delay ensures the vault state settles before LUT population begins. A fresh blockhash is then fetched to prevent expiration errors.

LUT population failure does not affect vault functionality. The vault remains fully operational even if LUT population fails.For non-Node.js environments, use these alternatives:

// Browser/Universal: Using setTimeout
setTimeout(async () => {
  // LUT population code here
}, 0);

// Browser/Universal: Using Promise
Promise.resolve().then(async () => {
  // LUT population code here
});

Full Code Example

import {
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  address,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstructions,
  signTransactionMessageWithSigners,
  sendAndConfirmTransactionFactory,
  getSignatureFromTransaction,
} from '@solana/kit';
import {
  KaminoManager,
  KaminoVaultConfig,
  getMedianSlotDurationInMsFromLastEpochs,
} from '@kamino-finance/klend-sdk';
import { parseKeypairFile } from '@kamino-finance/klend-sdk/dist/utils/signer.js';
import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
import { Decimal } from 'decimal.js';

const KEYPAIR_FILE = '/path/to/your/keypair.json';

const adminSigner = await parseKeypairFile(KEYPAIR_FILE);

const rpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
const rpcSubscriptions = createSolanaRpcSubscriptions('wss://api.mainnet-beta.solana.com');
const slotDuration = await getMedianSlotDurationInMsFromLastEpochs();
const kaminoManager = new KaminoManager(rpc, slotDuration);

const kaminoVaultConfig = new KaminoVaultConfig({
  admin: adminSigner,
  tokenMint: address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
  tokenMintProgramId: TOKEN_PROGRAM_ADDRESS,
  performanceFeeRatePercentage: new Decimal(15.0),
  managementFeeRatePercentage: new Decimal(2.0),
  name: 'MyCustomVault',
  vaultTokenSymbol: 'USDC',
  vaultTokenName: 'MyCustomVaultToken',
  minDepositAmount: new Decimal(1000000),
  minWithdrawAmount: new Decimal(1000000),
  minInvestAmount: new Decimal(1000000),
  minInvestDelaySlots: 150,
  unallocatedWeight: 500,
  unallocatedTokensCap: new Decimal(2000000),
} as any);

const { vault: vaultSigner, initVaultIxs: instructions } = await kaminoManager.createVaultIxs(kaminoVaultConfig);

const allInstructions = [
  ...instructions.createAtaIfNeededIxs,
  ...instructions.initVaultIxs,
  instructions.createLUTIx,
  instructions.initSharesMetadataIx,
];

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

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

const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);

const signature = getSignatureFromTransaction(signedTransaction);

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

console.log('Vault creation successful! Vault ID:', vaultSigner.address);

setImmediate(async () => {
  try {
    await new Promise((resolve) => setTimeout(resolve, 2000));

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

    const lutMessage = pipe(
      createTransactionMessage({ version: 0 }),
      (tx) => setTransactionMessageFeePayerSigner(adminSigner, tx),
      (tx) => setTransactionMessageLifetimeUsingBlockhash(lutBlockhash, tx),
      (tx) => appendTransactionMessageInstructions(instructions.populateLUTIxs, tx)
    );

    const signedLutTx = await signTransactionMessageWithSigners(lutMessage);
    const lutSignature = getSignatureFromTransaction(signedLutTx);

    await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signedLutTx, {
      commitment: 'confirmed',
      skipPreflight: true,
    });
  } catch (error) {
    // LUT population failure doesn't affect vault functionality
  }
});

Developers

Earn

Borrow

Miscellaneous

Creating a Vault

Import Dependencies

Load Admin Keypair and Initialize Manager

Configure Vault Parameters

Generate Vault Creation Instructions

Build and Sign Transaction

Send and Confirm Transaction

Background LUT Population

Full Code Example

Developers

Earn

Borrow

Miscellaneous

​Creating a Vault

​Import Dependencies

​Load Admin Keypair and Initialize Manager

​Configure Vault Parameters

​Generate Vault Creation Instructions

​Build and Sign Transaction

​Send and Confirm Transaction

​Background LUT Population

​Full Code Example

Creating a Vault

Import Dependencies

Load Admin Keypair and Initialize Manager

Configure Vault Parameters

Generate Vault Creation Instructions

Build and Sign Transaction

Send and Confirm Transaction

Background LUT Population

Full Code Example