Create a Vault

import {
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  address,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstructions,
  signTransactionMessageWithSigners,
  assertIsTransactionWithinSizeLimit,
  sendAndConfirmTransactionFactory,
  getSignatureFromTransaction,
  type Instruction,
} from '@solana/kit';
import {
  KaminoManager,
  KaminoVault,
  KaminoVaultConfig,
  getMedianSlotDurationInMsFromLastEpochs,
  sleep,
} 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: 1000,
  minWithdrawAmount: 10,
  minInvestAmount: 0,
  minInvestDelaySlots: 0,
  withdrawalPenaltyBps: 1,
  withdrawalPenaltyLamports: 1,
  crankFundFeePerReserve: 1,
});

const { vault: vaultSigner, initVaultIxs: instructions } = await kaminoManager.createVaultIxs(kaminoVaultConfig);
console.log('New vault address:', vaultSigner.address);

async function sendTransaction(ixs: Instruction[], label: string) {
  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(ixs, tx)
  );

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

  await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signedTransaction, {
    commitment: 'confirmed',
    skipPreflight: true,
  });
  console.log(`${label}:`, getSignatureFromTransaction(signedTransaction));
}

await sendTransaction(
  [
    ...instructions.createAtaIfNeededIxs,
    ...instructions.initVaultIxs,
    instructions.createLUTIx,
    ...instructions.cleanupIxs,
  ],
  'Vault initialized'
);

const vaultFarm = instructions.createVaultFarms.createVaultFarmIxs;
await sendTransaction(
  [...vaultFarm.setupFarmIxs, ...vaultFarm.updateFarmIxs, instructions.setFarmToVaultIxs.setFarmToVaultIx],
  'Vault Farm created'
);

const flcFarm = instructions.createVaultFarms.createFLCVaultFarmIxs;
const setFlcFarm = instructions.setFarmToVaultIxs.setFLCFarmToVaultIx;
if (flcFarm && setFlcFarm) {
  await sendTransaction(
    [...flcFarm.setupFarmIxs, ...flcFarm.updateFarmIxs, setFlcFarm],
    'First Loss Capital Farm created'
  );
}

await sleep(2000);
await sendTransaction(
  [...instructions.populateLUTIxs, instructions.initSharesMetadataIx],
  'Lookup table filled and share metadata set'
);

const vault = new KaminoVault(rpc, vaultSigner.address, slotDuration);
const status = await kaminoManager.getVaultSetupStatus(vault, kaminoVaultConfig);

if (status.allSet) {
  console.log('Vault created and fully set up:', vaultSigner.address);
} else {
  console.log('Setup incomplete:', status);
}

const vaultState = await vault.getState();
const vaultReservesMap = await kaminoManager.loadVaultReserves(vaultState);

const { updateVaultConfigIx: unallocWeightIx } =
  await kaminoManager.updateVaultUnallocatedWeightIxs(vault, 500, vaultReservesMap, adminSigner);
const { updateVaultConfigIx: unallocCapIx } =
  await kaminoManager.updateVaultUnallocatedTokensCapIxs(vault, 2000000, vaultReservesMap, adminSigner);

await sendTransaction([unallocWeightIx, unallocCapIx], 'Unallocated weight and cap set');