Allocations

import { createSolanaRpc, address } from '@solana/kit';
import { KaminoVault } from '@kamino-finance/klend-sdk';

const vault = new KaminoVault(
  createSolanaRpc('https://api.mainnet-beta.solana.com'),
  address('<VAULT_ADDRESS>')
);

const allocations = await vault.getVaultAllocations();

for (const [reserveAddress, overview] of allocations) {
  console.log(
    `Reserve: ${reserveAddress}: weight ${overview.targetWeight.toString()}, ` +
    `allocation: ${overview.ctokenAllocation.toString()}, ` + 
    `cap: ${overview.tokenAllocationCap.toString()}`
  );
}

import { createSolanaRpc, address } from '@solana/kit';
import { KaminoManager, KaminoVault } from '@kamino-finance/klend-sdk';
import { Decimal } from 'decimal.js';

const rpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
const vault = new KaminoVault(rpc, address('<VAULT_ADDRESS>'));
const kaminoManager = new KaminoManager(rpc);

const vaultTokenPrice = new Decimal(1.0); // adjust for non-stablecoin vaults
const vaultOverview = await kaminoManager.getVaultOverview(vault, vaultTokenPrice);

console.log('Overview:', vaultOverview);
console.log('Reserve farm incentives:', vaultOverview.reservesFarmsIncentives);

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

const vault = new KaminoVault(rpc, address('<VAULT_ADDRESS>'));
const reserveAddress = address('<RESERVE_ADDRESS>');

// Fetch the reserve state from chain
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);
const signature = getSignatureFromTransaction(signed);

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

console.log('Allocation updated! Signature:', signature);

const removeIx = await kaminoManager.removeReserveFromAllocationIx(
  vault,
  address('<RESERVE_ADDRESS>'),
  adminSigner,
);

if (removeIx) {
  const instructions = [removeIx];
  // Build and send transaction using the same pattern as above
}

const response = await fetch('https://api.kamino.finance/kvaults/vaults/<VAULT_ADDRESS>');
const vault = await response.json();

// Allocation data is part of the vault state
console.log('Vault state:', vault.state);

const response = await fetch(
  'https://api.kamino.finance/kvaults/vaults/<VAULT_ADDRESS>/allocation-volume/history'
);
const history = await response.json();
console.log('Allocation history:', history);

yarn kamino-manager update-vault-reserve-allocation \
  --vault <VAULT_ADDRESS> \
  --reserve <RESERVE_ADDRESS> \
  --allocation-weight <WEIGHT> \
  --allocation-cap <CAP> \
  --allocation-type <number> \
  --priority <number> \
  --mode simulate

yarn kamino-manager update-vault-reserve-allocation \
  --vault 67dqmR76uAbjX6e81A1ganKv3ou31WUMEdeWJkwVfeXy \
  --reserve 9GJ9GBRwCp4pHmWrQ43L5xpc9Vykg7jnfwcFGN8FoHYu \
  --allocation-weight 100000 \
  --allocation-cap 18446744073709.551615 \
  --mode simulate

yarn kamino-manager remove-vault-allocation \
  --vault <VAULT_ADDRESS> \
  --reserve <RESERVE_ADDRESS> \
  --mode simulate

yarn kamino-manager remove-vault-allocation \
  --vault 67dqmR76uAbjX6e81A1ganKv3ou31WUMEdeWJkwVfeXy \
  --reserve F22tnLsbv66vEU2GZRc7coaqZsr8UcBbyp9V2kqWAiWK \
  --mode simulate

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