Creating a Vault

UI
SDK
API
Kamino CLI

Creation Flow

Configure Required Parameters

Set the vault name, deposit token, vault farm, receipt token name and ticker.

Set Fee Structure

Configure performance and AUM fees (optional — defaults to 0%).

Configure Advanced Settings

Set minimum deposit/withdrawal amounts, invest parameters, and withdrawal penalties (optional).

Submit Transaction

Sign and submit the vault creation transaction. The wallet used to sign should have 1000 lamports of the vault token, used as bootstrapping deposit.

Complete Initial Setup

Configure allocations, set allocation admin and transfer admin to multisig. See Initial Setup.

Required Parameters

Parameter	Type	Editable	Description
Vault Name	String	Yes	Human-readable vault identifier (max 40 characters)
Token (Deposit Token)	Token	No (immutable)	Token the vault accepts for deposits; determines available reserves for allocation
Vault Description	Text	Yes	Optional description of vault strategy
Receipt Token Ticker	String	Suffix only	Format: `kv[DEPOSIT_SYMBOL]-[CUSTOM_SUFFIX]`; 10 character maximum; e.g. `kvUSDC-agg`, including the prefix
Receipt Token Name	String	Suffix only	Format: `kVault [TICKER_CUSTOM_SUFFIX] [CUSTOM_NAME]`; Full name for receipt token issued to depositors; 32 character maximum, including the prefix

The deposit token and receipt token ticker prefix (kv[symbol]-) are immutable after creation. Choose carefully.

Fee Configuration

Both fees default to 0% and are editable after creation.

Parameter	Type	Default	Description
Performance Fee (`PerformanceFeeBps`)	Basis points	0	Fee on vault profits, paid to vault admin
AUM Fee (`ManagementFeeBps`)	Basis points	0	Annual fee on total assets under management, paid to vault admin

Fees accrue continuously in the deposit token and are collected manually via the Vault Settings interface. See Fee Management for details.

Advanced Settings

All advanced settings are optional at creation and editable post-creation.

Parameter	Type	Default	Description
Min Deposit Amount (`MinDepositAmount`)	Lamports	1000	Minimum deposit size; prevents dust deposits and exploit vectors
Min Withdraw Amount (`MinWithdrawAmount`)	Lamports	10	Minimum withdrawal size; prevents dust withdrawals
Min Invest Amount (`MinInvestAmount`)	Lamports	0	Minimum size for investment instructions; prevents dust operations
Min Invest Delay (`MinInvestDelaySlots`)	Slots	0	Delay in slots before investment executes; security parameter
Withdrawal Penalty BPS (`WithdrawalPenaltyBps`)	Basis points	1-2 (suggested)	Percentage-based withdrawal fee
Withdrawal Penalty Lamports (`WithdrawalPenaltyLamports`)	Lamports	Non-zero (suggested)	Absolute withdrawal fee
Crank fund fee per reserve (`CrankFundFeePerReserve`)	Lamports	1-2 (suggested)	Fee taken on each deposit to cover the cost of investing deposited funds into reserves
AllocationAdmin (`AllocationAdmin`)	PublicKey	Default Pubkey (unset)	Has the right to update allocation weights and caps; cannot add or remove new allocations

Withdrawal penalties are a security mechanism, not manager revenue. The system takes the MAX of the BPS-based and lamports-based fee. Penalties are returned to the vault, benefiting remaining depositors. They prevent an exploit where users deposit before autocompound, claim rewards, and immediately withdraw.

Next Steps

After vault creation, proceed to Initial Setup to configure allocations, create a farm, and transfer admin to your multisig.

Creating a Vault via SDK

Create a Kamino vault programmatically using the TypeScript SDK. The SDK manages vault initialization, metadata setup, and lookup table creation.

Import Dependencies

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

Initialize KaminoManager

Load the admin keypair and initialize the manager with RPC and 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);

Use a private RPC endpoint for production. Public RPCs are rate-limited and may cause transaction failures.

Configure Vault

Create a KaminoVaultConfig with the vault’s core identity and fee structure. The table below maps UI fields to SDK config fields.

const kaminoVaultConfig = new KaminoVaultConfig({
  admin: adminSigner,
  tokenMint: address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'), // USDC
  tokenMintProgramId: TOKEN_PROGRAM_ADDRESS,
  performanceFeeRatePercentage: new Decimal(15.0),
  managementFeeRatePercentage: new Decimal(2.0),
  name: 'MyCustomVault',
  vaultTokenSymbol: 'USDC',
  vaultTokenName: 'MyCustomVaultToken',
  // Optional — defaults shown below:
  minDepositAmount: 1000,        // lamports (default: 1000)
  minWithdrawAmount: 10,         // lamports (default: 10)
  minInvestAmount: 0,            // lamports (default: 0)
  minInvestDelaySlots: 0,        // slots (default: 0)
  withdrawalPenaltyBps: 1,       // basis points (default: 1)
  withdrawalPenaltyLamports: 1,  // lamports (default: 1)
  crankFundFeePerReserve: 1,     // lamports (default: 1)
});

UI Field	SDK Config Field	Notes
Vault Name	`name`	Human-readable identifier (max 40 characters)
Token (Deposit Token)	`tokenMint`	SPL token mint address (immutable)
Receipt Token Name	`vaultTokenName`	Display name for shares (max 10 characters)
Receipt Token Ticker	`vaultTokenSymbol`	Token symbol for shares (max 5 characters)
Performance Fee	`performanceFeeRatePercentage`	Percentage (not basis points)
AUM Fee	`managementFeeRatePercentage`	Annual percentage
Min Deposit Amount	`minDepositAmount`	Optional. Lamports (default: 1000)
Min Withdraw Amount	`minWithdrawAmount`	Optional. Lamports (default: 10)
Min Invest Amount	`minInvestAmount`	Optional. Lamports (default: 0)
Min Invest Delay	`minInvestDelaySlots`	Optional. Slots (default: 0)
Withdrawal Penalty BPS	`withdrawalPenaltyBps`	Optional. Basis points (default: 1)
Withdrawal Penalty Lamports	`withdrawalPenaltyLamports`	Optional. Lamports (default: 1)
Crank Fund Fee	`crankFundFeePerReserve`	Optional. Lamports (default: 1)

The operational parameters above are optional during vault creation — omit them to use the defaults. All parameters are editable post-creation using specialized update methods. Unallocated weight and cap are set post-creation only. See Initial Setup — SDK for the full post-creation configuration flow.

Generate and Send Transaction

Generate the vault creation instructions and submit.

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

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

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 created! Address:', vaultSigner.address);

The setFarmToVaultIxs register the Vault Farm, First Loss Capital Farm and Autocompound Farm addresses on the vault. The farm accounts themselves are created in the next step.

Create and Attach Farms

The createVaultIxs method generates instructions for the Vault Farm (reward distribution), First Loss Capital Farm (loss-absorbing capital), and Autocompound Farm. Each farm requires two sequential transactions: setup and update. We use a helper to reduce transaction boilerplate:

// Helper to build, sign, and send a transaction
async function buildAndSendTx(ixs) {
  const { value: blockhash } = await rpc.getLatestBlockhash({ commitment: 'finalized' }).send();
  const signed = await signTransactionMessageWithSigners(
    pipe(
      createTransactionMessage({ version: 0 }),
      (tx) => setTransactionMessageFeePayerSigner(adminSigner, tx),
      (tx) => setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
      (tx) => appendTransactionMessageInstructions(ixs, tx)
    )
  );
  await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signed, {
    commitment: 'confirmed',
    skipPreflight: true,
  });
}

const [vaultFarm, flcFarm] = instructions.createVaultFarms;

for (const farm of [vaultFarm, flcFarm]) {
  await buildAndSendTx(farm.setupFarmIxs);  // Create farm account
  await buildAndSendTx(farm.updateFarmIxs);  // Configure farm-side settings
  console.log('Farm created:', farm.farm.address);
}

If farms are not created during vault initialization, they can be created post-creation using kaminoManager.createVaultFarmIxs(). See Farms & Rewards.

Populate Lookup Table

After vault creation, populate the lookup table (LUT). This optimizes future transaction sizes but is not required for vault functionality.

await new Promise((resolve) => setTimeout(resolve, 2000)); // Wait for vault state to settle
await buildAndSendTx(instructions.populateLUTIxs);

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',
  // Optional — defaults shown below:
  minDepositAmount: 1000,
  minWithdrawAmount: 10,
  minInvestAmount: 0,
  minInvestDelaySlots: 0,
  withdrawalPenaltyBps: 1,
  withdrawalPenaltyLamports: 1,
  crankFundFeePerReserve: 1,
});

// Helper to build, sign, and send a transaction
async function buildAndSendTx(ixs) {
  const { value: blockhash } = await rpc.getLatestBlockhash({ commitment: 'finalized' }).send();
  const signed = await signTransactionMessageWithSigners(
    pipe(
      createTransactionMessage({ version: 0 }),
      (tx) => setTransactionMessageFeePayerSigner(adminSigner, tx),
      (tx) => setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
      (tx) => appendTransactionMessageInstructions(ixs, tx)
    )
  );
  await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signed, {
    commitment: 'confirmed',
    skipPreflight: true,
  });
}

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

// Step 1: Create the vault
await buildAndSendTx([
  ...instructions.createAtaIfNeededIxs,
  ...instructions.initVaultIxs,
  instructions.createLUTIx,
  instructions.initSharesMetadataIx,
  ...instructions.setFarmToVaultIxs,
]);
console.log('Vault created! Address:', vaultSigner.address);

// Step 2: Create and attach farms (Vault Farm + First Loss Capital Farm)
for (const farm of instructions.createVaultFarms) {
  await buildAndSendTx(farm.setupFarmIxs);
  await buildAndSendTx(farm.updateFarmIxs);
  console.log('Farm created:', farm.farm.address);
}

// Step 3: Populate LUT (async, non-blocking)
setTimeout(async () => {
  try {
    await new Promise((resolve) => setTimeout(resolve, 2000));
    await buildAndSendTx(instructions.populateLUTIxs);
  } catch (error) {
    // LUT population failure doesn't affect vault functionality
  }
}, 0);

Learn More

For deeper SDK reference, see Earn Vaults — SDK and the full SDK examples on GitHub.

Creating a Vault via CLI

Create a vault using the Kamino Manager CLI.

Before starting, complete the CLI Installation & Setup guide. Commands require a .env file with ADMIN (path to vault owner keypair) and RPC configured.

CLI Modes

All commands support different execution modes:

Mode	Description
`inspect`	Preview the transaction without executing
`simulate`	Test the transaction simulation on-chain
`execute`	Execute the transaction immediately
`multisig`	Generate a multisig proposal for the operation

Always start with simulate to verify transactions before running with execute.

Create the Vault

Run Create Command

yarn kamino-manager create-vault \
  --mint <TOKEN_MINT> \
  --mode execute

Replace <TOKEN_MINT> with the SPL token mint address (e.g., EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v for USDC).

For testing, add the --staging flag to use the staging program ID.

Save Vault Address

Save the vault address from the command output. This address is required for all subsequent vault operations.

The CLI create-vault command creates the vault with default settings. Use the SDK or UI to configure advanced parameters (fees, min amounts, withdrawal penalties) during or after creation. Fee updates are available via CLI — see Vault Settings.

Next Steps

After creation, configure allocations and transfer admin:

# Add a reserve allocation
yarn kamino-manager update-vault-reserve-allocation \
  --vault <VAULT_ADDRESS> \
  --reserve <RESERVE_ADDRESS> \
  --allocation-weight 100000 \
  --allocation-cap 18446744073709.551615 \
  --mode simulate

# Transfer admin to multisig
yarn kamino-manager update-vault-pending-admin \
  --vault <VAULT_ADDRESS> \
  --new-admin <MULTISIG_PUBKEY> \
  --mode execute

See Initial Setup for the full post-creation checklist.

Learn More

For the complete CLI reference, see Vault Operations — CLI and CLI Installation & Setup.

Getting Started

Management

Data & API

Reference

Creation Flow

Required Parameters

Fee Configuration

Advanced Settings

Next Steps

Creating a Vault via SDK

Full Code Example

Learn More

Learn More

Creating a Vault via CLI

CLI Modes

Create the Vault

Next Steps

Learn More

Getting Started

Management

Data & API

Reference

​Creation Flow

​Required Parameters

​Fee Configuration

​Advanced Settings

​Next Steps

​Creating a Vault via SDK

​Full Code Example

​Learn More

​Learn More

​Creating a Vault via CLI

​CLI Modes

​Create the Vault

​Next Steps

​Learn More

Creation Flow

Required Parameters

Fee Configuration

Advanced Settings

Next Steps

Creating a Vault via SDK

Full Code Example

Learn More

Learn More

Creating a Vault via CLI

CLI Modes

Create the Vault

Next Steps

Learn More