@kamino-finance/klend-sdk 5.10.9 → 5.10.11

package/src/classes/types.ts

@@ -4,12 +4,14 @@ import Decimal from 'decimal.js/decimal';
 /** the populateLUTIxs should be executed in a separate transaction as we cannot create and populate a lookup table in the same tx */
 export type InitVaultIxs = {
   initVaultIxs: TransactionInstruction[];
+  createLUTIx: TransactionInstruction;
   populateLUTIxs: TransactionInstruction[];
 };
 
 export type AcceptVaultOwnershipIxs = {
   acceptVaultOwnershipIx: TransactionInstruction;
-  updateLUTIxs: TransactionInstruction[];
+  initNewLUTIx: TransactionInstruction;
+  updateLUTIxs: TransactionInstruction[]; // this has to be executed in a transaction after the initNewLUTIx is executed
 };
 
 export type UpdateReserveAllocationIxs = {
@@ -46,3 +48,9 @@ export type UserSharesForVault = {
   stakedShares: Decimal;
   totalShares: Decimal;
 };
+
+export type ReserveAllocationOverview = {
+  targetWeight: Decimal;
+  tokenAllocationCap: Decimal;
+  ctokenAllocation: Decimal;
+};

package/src/classes/vault.ts

@@ -72,6 +72,7 @@ import {
   AcceptVaultOwnershipIxs,
   DepositIxs,
   InitVaultIxs,
+  ReserveAllocationOverview,
   SyncVaultLUTIxs,
   UpdateReserveAllocationIxs,
   UpdateVaultConfigIxs,
@@ -234,7 +235,7 @@ export class KaminoVaultClient {
       lut.toString()
     );
 
-    const ixns = [createVaultIx, initVaultIx, createLUTIx, setLUTIx];
+    const ixns = [createVaultIx, initVaultIx, setLUTIx];
 
     if (vaultConfig.getPerformanceFeeBps() > 0) {
       const setPerformanceFeeIx = this.updateUninitialisedVaultConfigIx(
@@ -264,7 +265,7 @@ export class KaminoVaultClient {
       ixns.push(setNameIx);
     }
 
-    return { vault: vaultState, initVaultIxs: { initVaultIxs: ixns, populateLUTIxs: insertIntoLUTIxs } };
+    return { vault: vaultState, initVaultIxs: { initVaultIxs: ixns, createLUTIx, populateLUTIxs: insertIntoLUTIxs } };
   }
 
   /**
@@ -295,7 +296,7 @@ export class KaminoVaultClient {
       ctokenVault: cTokenVault,
       systemProgram: SystemProgram.programId,
       rent: SYSVAR_RENT_PUBKEY,
-      tokenProgram: TOKEN_PROGRAM_ID,
+      reserveCollateralTokenProgram: vaultState.tokenProgram,
     };
 
     const updateReserveAllocationArgs: UpdateReserveAllocationArgs = {
@@ -337,12 +338,14 @@ export class KaminoVaultClient {
    * @param vault the vault to update
    * @param mode the field to update (based on VaultConfigFieldKind enum)
    * @param value the value to update the field with
+   * @param [signer] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to batch multiple ixs in the same tx
    * @returns a struct that contains the instruction to update the field and an optional list of instructions to update the lookup table
    */
   async updateVaultConfigIxs(
     vault: KaminoVault,
     mode: VaultConfigFieldKind,
-    value: string
+    value: string,
+    signer?: PublicKey
   ): Promise<UpdateVaultConfigIxs> {
     const vaultState: VaultState = await vault.getState(this.getConnection());
 
@@ -351,6 +354,9 @@ export class KaminoVaultClient {
       vaultState: vault.address,
       klendProgram: this._kaminoLendProgramId,
     };
+    if (signer) {
+      updateVaultConfigAccs.adminAuthority = signer;
+    }
 
     const updateVaultConfigArgs: UpdateVaultConfigArgs = {
       entry: mode,
@@ -525,12 +531,12 @@ export class KaminoVaultClient {
 
     const LUTIxs = [];
     const [initNewLUTIx, newLUT] = initLookupTableIx(vaultState.pendingAdmin, await this.getConnection().getSlot());
-    LUTIxs.push(initNewLUTIx);
 
     const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(
       vaultState.pendingAdmin,
       newLUT,
-      accountsInExistentLUT
+      accountsInExistentLUT,
+      []
     );
 
     LUTIxs.push(...insertIntoLUTIxs);
@@ -538,13 +544,15 @@ export class KaminoVaultClient {
     const updateVaultConfigIxs = await this.updateVaultConfigIxs(
       vault,
       new VaultConfigField.LookupTable(),
-      newLUT.toString()
+      newLUT.toString(),
+      vaultState.pendingAdmin
     );
     LUTIxs.push(updateVaultConfigIxs.updateVaultConfigIx);
     LUTIxs.push(...updateVaultConfigIxs.updateLUTIxs);
 
     const acceptVaultOwnershipIxs: AcceptVaultOwnershipIxs = {
       acceptVaultOwnershipIx,
+      initNewLUTIx,
       updateLUTIxs: LUTIxs,
     };
 
@@ -720,7 +728,6 @@ export class KaminoVaultClient {
       userTokenAta: userTokenAta,
       userSharesAta: userSharesAta,
       tokenProgram: tokenProgramID,
-      instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
       klendProgram: this._kaminoLendProgramId,
       sharesTokenProgram: TOKEN_PROGRAM_ID,
     };
@@ -802,7 +809,7 @@ export class KaminoVaultClient {
    * This function will return a struct with the instructions to unstake from the farm if necessary and the instructions for the missing ATA creation instructions, as well as one or multiple withdraw instructions, based on how many reserves it's needed to withdraw from. This might have to be split in multiple transactions
    * @param user - user to withdraw
    * @param vault - vault to withdraw from
-   * @param shareAmount - share amount to withdraw, in order to withdraw everything, any value > user share amount
+   * @param shareAmount - share amount to withdraw (in tokens, not lamports), in order to withdraw everything, any value > user share amount
    * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
    * @param [vaultReservesMap] - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @param [farmState] - the state of the vault farm, if the vault has a farm. Optional. If not provided, it will be fetched
@@ -839,8 +846,8 @@ export class KaminoVaultClient {
     }
 
     // if the vault has allocations withdraw otherwise wtihdraw from available ix
-    const vaultAllocation = vaultState.vaultAllocationStrategy.find((allocation) =>
-      allocation.reserve.equals(PublicKey.default)
+    const vaultAllocation = vaultState.vaultAllocationStrategy.find(
+      (allocation) => !allocation.reserve.equals(PublicKey.default)
     );
 
     if (vaultAllocation) {
@@ -990,7 +997,6 @@ export class KaminoVaultClient {
     return withdrawIxns;
   }
 
-  // todo: make sure we also check the ata of the investor for the vault token exists
   /**
    * This will trigger invest by balancing, based on weights, the reserve allocations of the vault. It can either withdraw or deposit into reserves to balance them. This is a function that should be cranked
    * @param payer wallet that pays the tx
@@ -998,20 +1004,87 @@ export class KaminoVaultClient {
    * @returns - an array of invest instructions for each invest action required for the vault reserves
    */
   async investAllReservesIxs(payer: PublicKey, vault: KaminoVault): Promise<TransactionInstruction[]> {
-    //TODO: Order invest ixns by - invest that removes first, then invest that adds
     const vaultState = await vault.getState(this.getConnection());
-    const vaultReserves = this.getVaultReserves(vaultState);
+    const allReserves = this.getAllVaultReserves(vaultState);
+    if (allReserves.length === 0) {
+      throw new Error('No reserves found for the vault, please select at least one reserve for the vault');
+    }
+
+    const [allReservesStateMap, computedReservesAllocation] = await Promise.all([
+      this.loadVaultReserves(vaultState),
+      this.getVaultComputedReservesAllocation(vaultState),
+    ]);
+
+    const tokenProgram = await getAccountOwner(this.getConnection(), vaultState.tokenMint);
+    const [{ ata: _payerTokenAta, createAtaIx }] = createAtasIdempotent(payer, [
+      { mint: vaultState.tokenMint, tokenProgram },
+    ]);
+
+    // compute total vault holdings and expected distribution based on weights
+    const curentVaultAllocations = this.getVaultAllocations(vaultState);
+
+    const reservesToDisinvestFrom: PublicKey[] = [];
+
+    for (let index = 0; index < allReserves.length; index++) {
+      const reservePubkey = allReserves[index];
+      const reserveState = allReservesStateMap.get(reservePubkey)!;
+      const computedAllocation = computedReservesAllocation.get(reservePubkey)!;
+      const currentCTokenAllocation = curentVaultAllocations.get(reservePubkey)!.ctokenAllocation;
+
+      const reserveCollExchangeRate = reserveState.getCollateralExchangeRate();
+      const reserveAllocationLiquidityAmount = lamportsToDecimal(
+        currentCTokenAllocation.div(reserveCollExchangeRate),
+        vaultState.tokenMintDecimals.toNumber()
+      );
+
+      if (computedAllocation.lt(reserveAllocationLiquidityAmount)) {
+        reservesToDisinvestFrom.push(reservePubkey);
+      }
+    }
+
     const investIxnsPromises: Promise<TransactionInstruction[]>[] = [];
-    for (const reserve of vaultReserves) {
-      const reserveState = await Reserve.fetch(this.getConnection(), reserve, this._kaminoLendProgramId);
+    // invest first the reserves from which we disinvest, then the other ones
+    for (const reserve of reservesToDisinvestFrom) {
+      const reserveState = allReservesStateMap.get(reserve);
       if (reserveState === null) {
         throw new Error(`Reserve ${reserve.toBase58()} not found`);
       }
-      const investIxsPromise = this.investSingleReserveIxs(payer, vault, { address: reserve, state: reserveState });
+      const investIxsPromise = this.investSingleReserveIxs(
+        payer,
+        vault,
+        {
+          address: reserve,
+          state: reserveState!.state,
+        },
+        allReservesStateMap,
+        false
+      );
       investIxnsPromises.push(investIxsPromise);
     }
 
-    const investIxns = await Promise.all(investIxnsPromises).then((ixns) => ixns.flat());
+    for (const reserve of allReserves) {
+      if (!reservesToDisinvestFrom.includes(reserve)) {
+        const reserveState = allReservesStateMap.get(reserve);
+        if (reserveState === null) {
+          throw new Error(`Reserve ${reserve.toBase58()} not found`);
+        }
+        const investIxsPromise = this.investSingleReserveIxs(
+          payer,
+          vault,
+          {
+            address: reserve,
+            state: reserveState!.state,
+          },
+          allReservesStateMap,
+          false
+        );
+        investIxnsPromises.push(investIxsPromise);
+      }
+    }
+
+    let investIxns: TransactionInstruction[] = [];
+    investIxns.push(createAtaIx);
+    investIxns = await Promise.all(investIxnsPromises).then((ixns) => ixns.flat());
 
     return investIxns;
   }
@@ -1029,16 +1102,23 @@ export class KaminoVaultClient {
     payer: PublicKey,
     vault: KaminoVault,
     reserve: ReserveWithAddress,
-    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
+    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>,
+    createAtaIfNeeded: boolean = true
   ): Promise<TransactionInstruction[]> {
+    console.log('create invest ix for reserve', reserve.address.toBase58());
     const vaultState = await vault.getState(this.getConnection());
     const cTokenVault = getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId);
     const lendingMarketAuth = lendingMarketAuthPda(reserve.state.lendingMarket, this._kaminoLendProgramId)[0];
 
+    const ixs: TransactionInstruction[] = [];
+
     const tokenProgram = await getAccountOwner(this.getConnection(), vaultState.tokenMint);
     const [{ ata: payerTokenAta, createAtaIx }] = createAtasIdempotent(payer, [
       { mint: vaultState.tokenMint, tokenProgram },
     ]);
+    if (createAtaIfNeeded) {
+      ixs.push(createAtaIx);
+    }
 
     const investAccounts: InvestAccounts = {
       payer,
@@ -1400,6 +1480,49 @@ export class KaminoVaultClient {
     return ixns;
   }
 
+  /** Read the total holdings of a vault and the reserve weights and returns a map from each reserve to how many tokens should be deposited.
+   * @param vaultState - the vault state to calculate the allocation for
+   * @returns - a map from each reserve to how many tokens should be invested into
+   */
+  async getVaultComputedReservesAllocation(vaultState: VaultState): Promise<PubkeyHashMap<PublicKey, Decimal>> {
+    const holdings = await this.getVaultHoldings(vaultState);
+    const initialVaultAllocations = this.getVaultAllocations(vaultState);
+
+    const allReserves = this.getAllVaultReserves(vaultState);
+
+    let totalAllocation = new Decimal(0);
+    initialVaultAllocations.forEach((allocation) => {
+      totalAllocation = totalAllocation.add(allocation.targetWeight);
+    });
+    const expectedHoldingsDistribution = new PubkeyHashMap<PublicKey, Decimal>();
+
+    let totalLeftToInvest = holdings.total;
+    let currentAllocationSum = totalAllocation;
+    const ZERO = new Decimal(0);
+    while (totalLeftToInvest.gt(ZERO)) {
+      const totalLeftover = totalLeftToInvest;
+      for (const reserve of allReserves) {
+        const reserveWithWeight = initialVaultAllocations.get(reserve);
+        const targetAllocation = reserveWithWeight!.targetWeight.mul(totalLeftover).div(currentAllocationSum);
+        const reserveCap = reserveWithWeight!.tokenAllocationCap;
+        // todo: check if both target and reserveCap
+        const amountToInvest = Decimal.min(targetAllocation, reserveCap, totalLeftToInvest);
+        totalLeftToInvest = totalLeftToInvest.sub(amountToInvest);
+        if (amountToInvest.eq(reserveCap)) {
+          currentAllocationSum = currentAllocationSum.sub(reserveWithWeight!.targetWeight);
+        }
+        const reserveHasPreallocation = expectedHoldingsDistribution.has(reserve);
+        if (reserveHasPreallocation) {
+          expectedHoldingsDistribution.set(reserve, expectedHoldingsDistribution.get(reserve)!.add(amountToInvest));
+        } else {
+          expectedHoldingsDistribution.set(reserve, amountToInvest);
+        }
+      }
+    }
+
+    return expectedHoldingsDistribution;
+  }
+
   /**
    * This method returns the user shares balance for a given vault
    * @param user - user to calculate the shares balance for
@@ -1652,7 +1775,7 @@ export class KaminoVaultClient {
   /**
    * This will return the a map between reserve pubkey and the pct of the vault invested amount in each reserve
    * @param vaultState - the kamino vault to get reserves distribution for
-   * @returns a ma between reserve pubkey and the allocation pct for the reserve
+   * @returns a map between reserve pubkey and the allocation pct for the reserve
    */
   getAllocationsDistribuionPct(vaultState: VaultState): PubkeyHashMap<PublicKey, Decimal> {
     const allocationsDistributionPct = new PubkeyHashMap<PublicKey, Decimal>();
@@ -1661,7 +1784,6 @@ export class KaminoVaultClient {
     const filteredAllocations = vaultState.vaultAllocationStrategy.filter(
       (allocation) => !allocation.reserve.equals(PublicKey.default)
     );
-    console.log('filteredAllocations length', filteredAllocations.length);
     filteredAllocations.forEach((allocation) => {
       totalAllocation = totalAllocation.add(new Decimal(allocation.targetAllocationWeight.toString()));
     });
@@ -1676,6 +1798,30 @@ export class KaminoVaultClient {
     return allocationsDistributionPct;
   }
 
+  /**
+   * This will return the a map between reserve pubkey and the allocation overview for the reserve
+   * @param vaultState - the kamino vault to get reserves allocation overview for
+   * @returns a map between reserve pubkey and the allocation overview for the reserve
+   */
+  getVaultAllocations(vaultState: VaultState): PubkeyHashMap<PublicKey, ReserveAllocationOverview> {
+    const vaultAllocations = new PubkeyHashMap<PublicKey, ReserveAllocationOverview>();
+
+    vaultState.vaultAllocationStrategy.map((allocation) => {
+      if (allocation.reserve.equals(PublicKey.default)) {
+        return;
+      }
+
+      const allocationOverview: ReserveAllocationOverview = {
+        targetWeight: new Decimal(allocation.targetAllocationWeight.toString()),
+        tokenAllocationCap: new Decimal(allocation.tokenAllocationCap.toString()),
+        ctokenAllocation: new Decimal(allocation.ctokenAllocation.toString()),
+      };
+      vaultAllocations.set(allocation.reserve, allocationOverview);
+    });
+
+    return vaultAllocations;
+  }
+
   /**
    * This will return an unsorted hash map of all reserves that the given vault has allocations for, toghether with the amount that can be withdrawn from each of the reserves
    * @param vault - the kamino vault to get available liquidity to withdraw for
@@ -1728,7 +1874,11 @@ export class KaminoVaultClient {
    * @returns a hashmap from each reserve pubkey to the reserve state
    */
   getAllVaultReserves(vault: VaultState): PublicKey[] {
-    return vault.vaultAllocationStrategy.map((vaultAllocation) => vaultAllocation.reserve);
+    return vault.vaultAllocationStrategy
+      .map((vaultAllocation) => vaultAllocation.reserve)
+      .filter((reserve) => {
+        return !reserve.equals(PublicKey.default);
+      });
   }
 
   /**
@@ -2283,10 +2433,10 @@ export class KaminoVaultConfig {
   readonly tokenMint: PublicKey;
   /** The token mint program id */
   readonly tokenMintProgramId: PublicKey;
-  /** The performance fee rate of the vault, expressed as a decimal */
-  readonly performanceFeeRate: Decimal;
-  /** The management fee rate of the vault, expressed as a decimal */
-  readonly managementFeeRate: Decimal;
+  /** The performance fee rate of the vault, as percents, expressed as a decimal */
+  readonly performanceFeeRatePercentage: Decimal;
+  /** The management fee rate of the vault, as percents, expressed as a decimal */
+  readonly managementFeeRatePercentage: Decimal;
   /** The name to be stored on cain for the vault (max 40 characters). */
   readonly name: string;
 
@@ -2294,24 +2444,24 @@ export class KaminoVaultConfig {
     admin: PublicKey;
     tokenMint: PublicKey;
     tokenMintProgramId: PublicKey;
-    performanceFeeRate: Decimal;
-    managementFeeRate: Decimal;
+    performanceFeeRatePercentage: Decimal;
+    managementFeeRatePercentage: Decimal;
     name: string;
   }) {
     this.admin = args.admin;
     this.tokenMint = args.tokenMint;
-    this.performanceFeeRate = args.performanceFeeRate;
-    this.managementFeeRate = args.managementFeeRate;
+    this.performanceFeeRatePercentage = args.performanceFeeRatePercentage;
+    this.managementFeeRatePercentage = args.managementFeeRatePercentage;
     this.tokenMintProgramId = args.tokenMintProgramId;
     this.name = args.name;
   }
 
   getPerformanceFeeBps(): number {
-    return this.performanceFeeRate.mul(100).toNumber();
+    return this.performanceFeeRatePercentage.mul(100).toNumber();
   }
 
   getManagementFeeBps(): number {
-    return this.managementFeeRate.mul(100).toNumber();
+    return this.managementFeeRatePercentage.mul(100).toNumber();
   }
 }
 

package/src/client.ts

@@ -9,6 +9,7 @@ import {
   getAllUserMetadatasWithFilter,
   getProgramId,
   toJson,
+  getAllObligationAccounts,
 } from './lib';
 import * as fs from 'fs';
 import { Connection, GetProgramAccountsFilter, Keypair, PublicKey } from '@solana/web3.js';
@@ -65,6 +66,16 @@ async function main() {
       console.log(toJson(kaminoObligation?.refreshedStats));
     });
 
+  commands
+    .command('print-all-obligation-accounts')
+    .option(`--rpc <string>`, 'The RPC URL')
+    .action(async ({ rpc }) => {
+      const connection = new Connection(rpc, {});
+      for await (const obligationAccount of getAllObligationAccounts(connection)) {
+        console.log(toJson(obligationAccount.toJSON()));
+      }
+    });
+
   commands
     .command('print-reserve')
     .option(`--url <string>`, 'The admin keypair file')

package/src/client_kamino_manager.ts

@@ -245,14 +245,21 @@ async function main() {
         admin: mode === 'multisig' ? multisigPk : env.payer.publicKey,
         tokenMint: tokenMint,
         tokenMintProgramId: tokenProgramID,
-        performanceFeeRate: new Decimal(0.0),
-        managementFeeRate: new Decimal(0.0),
+        performanceFeeRatePercentage: new Decimal(0.0),
+        managementFeeRatePercentage: new Decimal(0.0),
         name,
       });
 
       const { vault: vaultKp, initVaultIxs: instructions } = await kaminoManager.createVaultIxs(kaminoVaultConfig);
 
-      const _createVaultSig = await processTxn(env.client, env.payer, instructions.initVaultIxs, mode, 2500, [vaultKp]);
+      const _createVaultSig = await processTxn(
+        env.client,
+        env.payer,
+        [...instructions.initVaultIxs, instructions.createLUTIx],
+        mode,
+        2500,
+        [vaultKp]
+      );
       await sleep(5000);
       const _populateLUTSig = await processTxn(env.client, env.payer, instructions.populateLUTIxs, mode, 2500, []);
 
@@ -327,7 +334,7 @@ async function main() {
         []
       );
 
-      mode === 'execute' && console.log('Pending admin updated:', updateVaultPendingAdminSig);
+      mode === 'execute' && console.log('Vault updated:', updateVaultPendingAdminSig);
     });
 
   commands
@@ -777,7 +784,7 @@ async function main() {
         kaminoVault,
         reserveWithAddress
       );
-      const investReserveSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 400_000);
+      const investReserveSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 800_000);
 
       mode === 'execute' && console.log('Reserve invested:', investReserveSig);
     });

package/src/idl_codegen_kamino_vault/errors/custom.ts

@@ -41,6 +41,8 @@ export type CustomError =
   | WithdrawResultsInZeroShares
   | CannotWithdrawZeroShares
   | ManagementFeeGreaterThanMaxAllowed
+  | VaultAUMZero
+  | MissingReserveForBatchRefresh
 
 export class DepositAmountsZero extends Error {
   static readonly code = 7000
@@ -504,6 +506,28 @@ export class ManagementFeeGreaterThanMaxAllowed extends Error {
   }
 }
 
+export class VaultAUMZero extends Error {
+  static readonly code = 7042
+  readonly code = 7042
+  readonly name = "VaultAUMZero"
+  readonly msg = "Vault assets under management are empty"
+
+  constructor(readonly logs?: string[]) {
+    super("7042: Vault assets under management are empty")
+  }
+}
+
+export class MissingReserveForBatchRefresh extends Error {
+  static readonly code = 7043
+  readonly code = 7043
+  readonly name = "MissingReserveForBatchRefresh"
+  readonly msg = "Missing reserve for batch refresh"
+
+  constructor(readonly logs?: string[]) {
+    super("7043: Missing reserve for batch refresh")
+  }
+}
+
 export function fromCode(code: number, logs?: string[]): CustomError | null {
   switch (code) {
     case 7000:
@@ -590,6 +614,10 @@ export function fromCode(code: number, logs?: string[]): CustomError | null {
       return new CannotWithdrawZeroShares(logs)
     case 7041:
       return new ManagementFeeGreaterThanMaxAllowed(logs)
+    case 7042:
+      return new VaultAUMZero(logs)
+    case 7043:
+      return new MissingReserveForBatchRefresh(logs)
   }
 
   return null

package/src/idl_codegen_kamino_vault/instructions/deposit.ts

@@ -20,7 +20,6 @@ export interface DepositAccounts {
   klendProgram: PublicKey
   tokenProgram: PublicKey
   sharesTokenProgram: PublicKey
-  instructionSysvarAccount: PublicKey
 }
 
 export const layout = borsh.struct([borsh.u64("maxAmount")])
@@ -42,11 +41,6 @@ export function deposit(
     { pubkey: accounts.klendProgram, isSigner: false, isWritable: false },
     { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
     { pubkey: accounts.sharesTokenProgram, isSigner: false, isWritable: false },
-    {
-      pubkey: accounts.instructionSysvarAccount,
-      isSigner: false,
-      isWritable: false,
-    },
   ]
   const identifier = Buffer.from([242, 35, 198, 137, 82, 225, 242, 182])
   const buffer = Buffer.alloc(1000)

package/src/idl_codegen_kamino_vault/instructions/updateReserveAllocation.ts

@@ -16,9 +16,9 @@ export interface UpdateReserveAllocationAccounts {
   reserveCollateralMint: PublicKey
   reserve: PublicKey
   ctokenVault: PublicKey
+  reserveCollateralTokenProgram: PublicKey
   systemProgram: PublicKey
   rent: PublicKey
-  tokenProgram: PublicKey
 }
 
 export const layout = borsh.struct([borsh.u64("weight"), borsh.u64("cap")])
@@ -39,9 +39,13 @@ export function updateReserveAllocation(
     },
     { pubkey: accounts.reserve, isSigner: false, isWritable: false },
     { pubkey: accounts.ctokenVault, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.reserveCollateralTokenProgram,
+      isSigner: false,
+      isWritable: false,
+    },
     { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
     { pubkey: accounts.rent, isSigner: false, isWritable: false },
-    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
   ]
   const identifier = Buffer.from([5, 54, 213, 112, 75, 232, 117, 37])
   const buffer = Buffer.alloc(1000)

package/src/idl_codegen_kamino_vault/types/ReserveConfig.ts

@@ -60,7 +60,8 @@ export interface ReserveConfigFields {
   debtWithdrawalCap: types.WithdrawalCapsFields
   elevationGroups: Array<number>
   disableUsageAsCollOutsideEmode: number
-  utilizationLimitBlockBorrowingAbove: number
+  /** Utilization (in percentage) above which borrowing is blocked. 0 to disable. */
+  utilizationLimitBlockBorrowingAbovePct: number
   /**
    * Whether this reserve should be subject to auto-deleveraging after deposit or borrow limit is
    * crossed.
@@ -147,7 +148,8 @@ export interface ReserveConfigJSON {
   debtWithdrawalCap: types.WithdrawalCapsJSON
   elevationGroups: Array<number>
   disableUsageAsCollOutsideEmode: number
-  utilizationLimitBlockBorrowingAbove: number
+  /** Utilization (in percentage) above which borrowing is blocked. 0 to disable. */
+  utilizationLimitBlockBorrowingAbovePct: number
   /**
    * Whether this reserve should be subject to auto-deleveraging after deposit or borrow limit is
    * crossed.
@@ -235,7 +237,8 @@ export class ReserveConfig {
   readonly debtWithdrawalCap: types.WithdrawalCaps
   readonly elevationGroups: Array<number>
   readonly disableUsageAsCollOutsideEmode: number
-  readonly utilizationLimitBlockBorrowingAbove: number
+  /** Utilization (in percentage) above which borrowing is blocked. 0 to disable. */
+  readonly utilizationLimitBlockBorrowingAbovePct: number
   /**
    * Whether this reserve should be subject to auto-deleveraging after deposit or borrow limit is
    * crossed.
@@ -297,8 +300,8 @@ export class ReserveConfig {
     })
     this.elevationGroups = fields.elevationGroups
     this.disableUsageAsCollOutsideEmode = fields.disableUsageAsCollOutsideEmode
-    this.utilizationLimitBlockBorrowingAbove =
-      fields.utilizationLimitBlockBorrowingAbove
+    this.utilizationLimitBlockBorrowingAbovePct =
+      fields.utilizationLimitBlockBorrowingAbovePct
     this.autodeleverageEnabled = fields.autodeleverageEnabled
     this.reserved1 = fields.reserved1
     this.borrowLimitOutsideElevationGroup =
@@ -336,7 +339,7 @@ export class ReserveConfig {
         types.WithdrawalCaps.layout("debtWithdrawalCap"),
         borsh.array(borsh.u8(), 20, "elevationGroups"),
         borsh.u8("disableUsageAsCollOutsideEmode"),
-        borsh.u8("utilizationLimitBlockBorrowingAbove"),
+        borsh.u8("utilizationLimitBlockBorrowingAbovePct"),
         borsh.u8("autodeleverageEnabled"),
         borsh.array(borsh.u8(), 1, "reserved1"),
         borsh.u64("borrowLimitOutsideElevationGroup"),
@@ -383,8 +386,8 @@ export class ReserveConfig {
       ),
       elevationGroups: obj.elevationGroups,
       disableUsageAsCollOutsideEmode: obj.disableUsageAsCollOutsideEmode,
-      utilizationLimitBlockBorrowingAbove:
-        obj.utilizationLimitBlockBorrowingAbove,
+      utilizationLimitBlockBorrowingAbovePct:
+        obj.utilizationLimitBlockBorrowingAbovePct,
       autodeleverageEnabled: obj.autodeleverageEnabled,
       reserved1: obj.reserved1,
       borrowLimitOutsideElevationGroup: obj.borrowLimitOutsideElevationGroup,
@@ -428,8 +431,8 @@ export class ReserveConfig {
       ),
       elevationGroups: fields.elevationGroups,
       disableUsageAsCollOutsideEmode: fields.disableUsageAsCollOutsideEmode,
-      utilizationLimitBlockBorrowingAbove:
-        fields.utilizationLimitBlockBorrowingAbove,
+      utilizationLimitBlockBorrowingAbovePct:
+        fields.utilizationLimitBlockBorrowingAbovePct,
       autodeleverageEnabled: fields.autodeleverageEnabled,
       reserved1: fields.reserved1,
       borrowLimitOutsideElevationGroup: fields.borrowLimitOutsideElevationGroup,
@@ -468,8 +471,8 @@ export class ReserveConfig {
       debtWithdrawalCap: this.debtWithdrawalCap.toJSON(),
       elevationGroups: this.elevationGroups,
       disableUsageAsCollOutsideEmode: this.disableUsageAsCollOutsideEmode,
-      utilizationLimitBlockBorrowingAbove:
-        this.utilizationLimitBlockBorrowingAbove,
+      utilizationLimitBlockBorrowingAbovePct:
+        this.utilizationLimitBlockBorrowingAbovePct,
       autodeleverageEnabled: this.autodeleverageEnabled,
       reserved1: this.reserved1,
       borrowLimitOutsideElevationGroup:
@@ -515,8 +518,8 @@ export class ReserveConfig {
       debtWithdrawalCap: types.WithdrawalCaps.fromJSON(obj.debtWithdrawalCap),
       elevationGroups: obj.elevationGroups,
       disableUsageAsCollOutsideEmode: obj.disableUsageAsCollOutsideEmode,
-      utilizationLimitBlockBorrowingAbove:
-        obj.utilizationLimitBlockBorrowingAbove,
+      utilizationLimitBlockBorrowingAbovePct:
+        obj.utilizationLimitBlockBorrowingAbovePct,
       autodeleverageEnabled: obj.autodeleverageEnabled,
       reserved1: obj.reserved1,
       borrowLimitOutsideElevationGroup: new BN(