Initial Setup

UI
SDK
API
Kamino CLI

Post-Creation Checklist

After creating your vault, complete these steps before it’s production-ready:

Configure Allocations

Add lending reserves and set allocation weights. Without allocations, the vault has nowhere to deploy capital. See Allocations.

Create the Farms (if not done on vault creation)

Each vault has three farm types: the Vault Farm (reward distribution), First Loss Capital Farm (loss-absorbing buffer), and Autocompound Farm (auto-reinvesting rewards). The Vault Farm and FLC Farm are created automatically during vault initialization via the SDK. The Autocompound Farm can be configured via the UI. If any farm was not created during initialization, it can be created and attached post-creation. See Farms & Rewards.

Transfer Admin to Multisig

Transfer vault admin to a Squads multisig. This is required before the vault goes live.

Transferring Admin to Multisig

All production vaults must be managed via multisig. Transfer your vault admin to a Squads multisig wallet before the vault accepts deposits.

Admin Transfer Process

The transfer uses a two-step process to prevent accidental transfers:

Initiate Transfer

The current admin submits a transfer to the new admin address (your Squads multisig). The vault enters a pending state (PendingVaultAdmin is set).

Claim Transfer

The new admin (multisig) submits a claim transaction to complete the transfer. This must be executed through Squads.

The current admin can cancel a pending transfer at any time before the new admin claims it.

Transferring the Allocation Admin role is a single step — the new admin does not need to claim it. See Vault Settings for all admin types.

Transaction Execution via SquadsX

Configure Changes

Make your desired changes on platform.kamino.com — update allocations, modify fees, adjust parameters, etc.

Simulate Transaction (optional)

Simulate the transaction to verify it succeeds and review the resulting changes.

Send Transaction

When using the SquadsX wallet, the Send flow automatically creates a proposal for the multisig. After the proposal is created, gather approvals and execute.

Transaction Execution via Squads

Once admin is transferred to a multisig, all vault management operations follow this flow:

Configure Changes

Make your desired changes on platform.kamino.com — update allocations, modify fees, adjust parameters, etc.

Simulate Transaction

The platform simulates the transaction and displays execution logs and success/failure status.

Copy Encoded Transaction

Copy the base58-encoded transaction string from the simulation output.

Execute in Squads

Import the encoded transaction into Squads, gather multisig approvals, and execute.

The process of copy-pasting the encoded transaction and manually creating the proposal happens automatically when using the SquadsX wallet.

This is the standard flow for all vault management operations going forward. The remaining documentation assumes you are executing transactions through your Squads multisig.

Initial Setup via SDK

Complete the post-creation setup programmatically: configure allocations, create a farm, and transfer admin to a multisig.

Step 1: Configure Allocations

Add lending reserves so the vault can deploy capital. See Allocations for full allocation management.

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

const adminSigner = await parseKeypairFile('/path/to/your/keypair.json');
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);

// Add first reserve allocation
const vault = new KaminoVault(rpc, address('<VAULT_ADDRESS>'));
const reserveAddress = address('<RESERVE_ADDRESS>');

const reserveState = await Reserve.fetch(rpc, reserveAddress);
const reserveWithAddress = { address: reserveAddress, state: reserveState! };

const allocConfig = new ReserveAllocationConfig(
  reserveWithAddress,
  100000,                  // allocation weight
  new Decimal('18446744073709551615'), // allocation cap (max = no cap)
  new ReserveType.Standard(),          // reserve type
  0,                                   // priority
);

const { updateReserveAllocationIx } =
  await kaminoManager.updateVaultReserveAllocationIxs(vault, allocConfig, adminSigner);
const instructions = [updateReserveAllocationIx];

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

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

const signed = await signTransactionMessageWithSigners(txMessage);
await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signed, {
  commitment: 'confirmed',
  skipPreflight: true,
});

console.log('Allocation added!');

Step 2: Create Farms (if not done on vault creation)

The SDK’s createVaultIxs method automatically generates instructions for both the Vault Farm and First Loss Capital Farm during vault initialization — see Creating a Vault. If farms were not created during initialization, they can be created post-creation using kaminoManager.createVaultFarmIxs(). The Autocompound Farm will be supported in a future SDK release. See Farms & Rewards for details.

Step 3: Transfer Admin to Multisig

The two-step admin transfer prevents accidental ownership changes.

// Step 1: Current admin initiates transfer
const { updateVaultConfigIx: transferIx} =
  await kaminoManager.updateVaultConfigIxs(
    vault,
    new VaultConfigField.PendingVaultAdmin(),
    '<SQUADS_MULTISIG_PUBKEY>',
    adminSigner,
  );
const transferInstructions = [transferIx, ...transferLUTIxs];

// Build and send transaction (same pattern as above)

// Step 2: New admin (multisig) claims ownership
// This must be executed through Squads as a multisig proposal
const { acceptVaultOwnershipIx, initNewLUTIx } =
  await kaminoManager.acceptVaultOwnershipIxs(vault);
const claimInstructions = [acceptVaultOwnershipIx, initNewLUTIx];
// Build and send transaction

After transferring admin to a multisig, all subsequent SDK-generated transactions should use --mode multisig equivalent patterns, building transaction instructions that are submitted as Squads proposals rather than executed directly.

Learn More

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

Initial Setup via CLI

Complete the post-creation setup using the Kamino Manager CLI.

Before starting, complete the CLI Installation & Setup guide. Commands require a .env file with ADMIN and RPC configured.

Step 1: Configure Allocations

Add lending reserves so the vault can deploy capital.

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

Repeat for each reserve you want to add. See Allocations for full allocation management.

Always run with --mode simulate first to verify, then --mode execute to send.

Step 2: Create Farms (if not done on vault creation)

Farm creation is not currently available via the Kamino CLI. Each vault has three farm types: Vault Farm, First Loss Capital Farm, and Autocompound Farm. The Vault Farm and FLC Farm are created automatically during vault initialization via the SDK. Use the SDK or UI to create farms if they were not created during initialization. See Farms & Rewards.

Step 3: Transfer Admin to Multisig

Initiate transfer (run as current admin):

yarn kamino-manager update-vault-pending-admin \
  --vault <VAULT_ADDRESS> \
  --new-admin <SQUADS_MULTISIG_PUBKEY> \
  --mode execute

Accept ownership (run with the multisig keypair in .env):

yarn kamino-manager accept-ownership \
  --vault <VAULT_ADDRESS> \
  --mode execute

For the accept step, set the new admin’s keypair as ADMIN in your .env file. For Squads multisig, this step must be executed through the Squads interface as a proposal.

Post-Transfer: Multisig Mode

Once admin is transferred, use --mode multisig for all subsequent operations:

yarn kamino-manager update-vault-reserve-allocation \
  --vault <VAULT_ADDRESS> \
  --reserve <RESERVE_ADDRESS> \
  --allocation-weight <WEIGHT> \
  --allocation-cap <CAP> \
  --mode multisig \
  --multisig <MULTISIG_PUBKEY>

The CLI generates a Base58-encoded transaction that can be submitted as a multisig proposal through Squads.

Learn More

For the complete CLI reference, see Vault Operations — CLI.

Getting Started

Management

Data & API

Reference

Post-Creation Checklist

Transferring Admin to Multisig

Admin Transfer Process

Transaction Execution via SquadsX

Transaction Execution via Squads

Initial Setup via SDK

Step 1: Configure Allocations

Step 2: Create Farms (if not done on vault creation)

Step 3: Transfer Admin to Multisig

Learn More

Learn More

Initial Setup via CLI

Step 1: Configure Allocations

Step 2: Create Farms (if not done on vault creation)

Step 3: Transfer Admin to Multisig

Post-Transfer: Multisig Mode

Learn More

Getting Started

Management

Data & API

Reference

​Post-Creation Checklist

​Transferring Admin to Multisig

​Admin Transfer Process

​Transaction Execution via SquadsX

​Transaction Execution via Squads

​Initial Setup via SDK

​Step 1: Configure Allocations

​Step 2: Create Farms (if not done on vault creation)

​Step 3: Transfer Admin to Multisig

​Learn More

​Learn More

​Initial Setup via CLI

​Step 1: Configure Allocations

​Step 2: Create Farms (if not done on vault creation)

​Step 3: Transfer Admin to Multisig

​Post-Transfer: Multisig Mode

​Learn More

Post-Creation Checklist

Transferring Admin to Multisig

Admin Transfer Process

Transaction Execution via SquadsX

Transaction Execution via Squads

Initial Setup via SDK

Step 1: Configure Allocations

Step 2: Create Farms (if not done on vault creation)

Step 3: Transfer Admin to Multisig

Learn More

Learn More

Initial Setup via CLI

Step 1: Configure Allocations

Step 2: Create Farms (if not done on vault creation)

Step 3: Transfer Admin to Multisig

Post-Transfer: Multisig Mode

Learn More