@kamino-finance/klend-sdk 5.11.12-beta.0 → 5.11.13

package/src/classes/utils.ts

@@ -222,17 +222,11 @@ export function calculateAPRFromAPY(apy: Decimal.Value) {
     .times(SLOTS_PER_YEAR);
 }
 
-export function sameLengthArrayEquals<T>(left: Array<T>, right: Array<T>): boolean {
+export function sameLengthArrayEquals(left: Array<number>, right: Array<number>): boolean {
   if (left.length != right.length) {
-    throw new Error(`Not same length: ${left.length} != ${right.length}`);
+    throw new Error(`Not same length: ${left.length} != ${left.length}`);
   }
-  return left.every((value, index) => {
-    const other = right[index];
-    if (value != null && typeof (value as any).eq === 'function') {
-      return (value as any).eq(other);
-    }
-    return value === other;
-  });
+  return left.every((value, index) => value === right[index]);
 }
 
 export function getTokenBalanceFromAccountInfoLamports(accountInfo: AccountInfo<Buffer>): Decimal {

package/src/classes/vault.ts

@@ -33,6 +33,8 @@ import {
   InitVaultAccounts,
   invest,
   InvestAccounts,
+  removeAllocation,
+  RemoveAllocationAccounts,
   updateAdmin,
   UpdateAdminAccounts,
   updateReserveAllocation,
@@ -92,8 +94,8 @@ import {
 } from './farm_utils';
 import { printHoldings } from './types_utils';
 
-export const kaminoVaultId = new PublicKey('kvauTFR8qm1dhniz6pYuBZkuene3Hfrs1VQhVRgCNrr');
-export const kaminoVaultStagingId = new PublicKey('STkvh7ostar39Fwr4uZKASs1RNNuYMFMTsE77FiRsL2');
+export const kaminoVaultId = new PublicKey('KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd');
+export const kaminoVaultStagingId = new PublicKey('stKvQfwRsQiKnLtMNVLHKS3exFJmZFsgfzBPWHECUYK');
 
 const TOKEN_VAULT_SEED = 'token_vault';
 const CTOKEN_VAULT_SEED = 'ctoken_vault';
@@ -338,6 +340,35 @@ export class KaminoVaultClient {
     return updateReserveAllocationIxs;
   }
 
+  /**
+   * This method removes a reserve from the vault allocation strategy if already part of the allocation strategy
+   * @param vault - vault to remove the reserve from
+   * @param reserve - reserve to remove from the vault allocation strategy
+   * @returns - an instruction to remove the reserve from the vault allocation strategy or undefined if the reserve is not part of the allocation strategy
+   */
+  async removeReserveFromAllocationIx(
+    vault: KaminoVault,
+    reserve: PublicKey
+  ): Promise<TransactionInstruction | undefined> {
+    const vaultState = await vault.getState(this.getConnection());
+
+    const reserveIsPartOfAllocation = vaultState.vaultAllocationStrategy.some((allocation) =>
+      allocation.reserve.equals(reserve)
+    );
+
+    if (!reserveIsPartOfAllocation) {
+      return undefined;
+    }
+
+    const accounts: RemoveAllocationAccounts = {
+      vaultAdminAuthority: vaultState.vaultAdminAuthority,
+      vaultState: vault.address,
+      reserve,
+    };
+
+    return removeAllocation(accounts);
+  }
+
   /**
    * Update a field of the vault. If the field is a pubkey it will return an extra instruction to add that account into the lookup table
    * @param vault the vault to update

package/src/client_kamino_manager.ts

@@ -16,12 +16,14 @@ import {
   Chain,
   DEFAULT_RECENT_SLOT_DURATION_MS,
   encodeTokenName,
+  initLookupTableIx,
   KaminoManager,
   KaminoMarket,
   KaminoVault,
   KaminoVaultConfig,
   LendingMarket,
   MAINNET_BETA_CHAIN_ID,
+  parseZeroPaddedUtf8,
   Reserve,
   ReserveAllocationConfig,
   ReserveWithAddress,
@@ -408,6 +410,14 @@ async function main() {
       mode === 'execute' && console.log('Management fee updated:', updateVaultConfigSig);
     });
 
+  commands.command('create-lut').action(async () => {
+    const env = initializeClient(false, false);
+    const initLutIx = initLookupTableIx(env.payer.publicKey, await env.connection.getSlot());
+
+    const updateVaultConfigSig = await processTxn(env.client, env.payer, [initLutIx[0]], 'execute', 2500, []);
+    console.log(`LUT created: ${initLutIx[1].toString()} tx id: ${updateVaultConfigSig}`);
+  });
+
   commands
     .command('sync-vault-lut')
     .requiredOption('--vault <string>', 'The vault address to sync')
@@ -1142,9 +1152,6 @@ async function main() {
         address: lendingMarketAddress,
         state: lendingMarketState,
       };
-      if (!lendingMarketState) {
-        throw new Error('Lending Market not found');
-      }
 
       if (mode === 'multisig') {
         throw new Error('If using multisig mode, multisig is required');
@@ -1163,6 +1170,106 @@ async function main() {
         );
     });
 
+  commands
+    .command('update-lending-market-name')
+    .requiredOption('--lending-market <string>', 'Lending Market address')
+    .requiredOption('--new-name <string>', 'Lending Market address')
+    .requiredOption(
+      `--mode <string>`,
+      'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage'
+    )
+    .option(`--staging`, 'If true, will use the staging programs')
+    .action(async ({ lendingMarket, newName, mode, staging }) => {
+      const env = initializeClient(mode === 'multisig', staging);
+      const lendingMarketAddress = new PublicKey(lendingMarket);
+      const lendingMarketState = await LendingMarket.fetch(env.connection, lendingMarketAddress, env.kLendProgramId);
+      if (!lendingMarketState) {
+        throw new Error('Lending Market not found');
+      }
+      const marketWithAddress = {
+        address: lendingMarketAddress,
+        state: lendingMarketState,
+      };
+
+      if (mode === 'multisig') {
+        throw new Error('If using multisig mode, multisig is required');
+      }
+
+      const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+      const currentName = parseZeroPaddedUtf8(lendingMarketState.name);
+      const newNameEncoded = encodeTokenName(newName);
+
+      console.log('Current name: ', currentName, ' encoded: ', lendingMarketState.name);
+      console.log('New name: ', newName, ' encoded: ', newNameEncoded);
+
+      // @ts-ignore
+      const newLendingMarket: LendingMarket = {
+        ...lendingMarketState,
+        name: newNameEncoded,
+      };
+
+      const ixns = kaminoManager.updateLendingMarketIxs(marketWithAddress, newLendingMarket);
+
+      const _updateLendingMarketSig = await processTxn(env.client, env.payer, ixns, mode, 2500, [], 400_000);
+
+      mode === 'execute' &&
+        console.log(
+          'Lending market name updated to -> ',
+          JSON.parse(JSON.stringify(lendingMarketState.lendingMarketOwnerCached))
+        );
+    });
+
+  commands
+    .command('update-reserve-config-debt-cap')
+    .requiredOption('--reserve <string>', 'Lending Market address')
+    .requiredOption(
+      `--mode <string>`,
+      'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage'
+    )
+    .option(`--staging`, 'If true, will use the staging programs')
+    .action(async ({ reserve, mode, staging }) => {
+      const env = initializeClient(mode === 'multisig', staging);
+      const reserveAddress = new PublicKey(reserve);
+      const reserveState = await Reserve.fetch(env.connection, reserveAddress, env.kLendProgramId);
+      if (!reserveState) {
+        throw new Error('Reserve not found');
+      }
+
+      const lendingMarketAddress = reserveState.lendingMarket;
+      const lendingMarketState = await LendingMarket.fetch(env.connection, lendingMarketAddress, env.kLendProgramId);
+      if (!lendingMarketState) {
+        throw new Error('Lending Market not found');
+      }
+
+      const marketWithAddress = {
+        address: lendingMarketAddress,
+        state: lendingMarketState,
+      };
+
+      if (mode === 'multisig') {
+        throw new Error('If using multisig mode, multisig is required');
+      }
+
+      const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+      const newReserveConfigFields: ReserveConfigFields = {
+        ...reserveState.config,
+        borrowLimit: new BN(1000),
+      };
+      const newReserveConfig: ReserveConfig = new ReserveConfig(newReserveConfigFields);
+
+      const ixns = await kaminoManager.updateReserveIxs(marketWithAddress, reserveAddress, newReserveConfig);
+
+      const _updateLendingMarketSig = await processTxn(env.client, env.payer, ixns, mode, 2500, [], 400_000);
+
+      mode === 'execute' &&
+        console.log(
+          'Lending market name updated to -> ',
+          JSON.parse(JSON.stringify(lendingMarketState.lendingMarketOwnerCached))
+        );
+    });
+
   await commands.parseAsync();
 }
 
@@ -1320,64 +1427,64 @@ function createAddExtraComputeUnitFeeTransaction(units: number, microLamports: n
   return ixns;
 }
 
-function parseReserveConfigFromFile(reserveConfigFromFile: any): ReserveConfig {
+function parseReserveConfigFromFile(farmConfigFromFile: any): ReserveConfig {
   const reserveConfigFields: ReserveConfigFields = {
-    status: reserveConfigFromFile.status,
-    loanToValuePct: reserveConfigFromFile.loanToValuePct,
-    liquidationThresholdPct: reserveConfigFromFile.liquidationThresholdPct,
-    minLiquidationBonusBps: reserveConfigFromFile.minLiquidationBonusBps,
-    protocolLiquidationFeePct: reserveConfigFromFile.protocolLiquidationFeePct,
-    protocolTakeRatePct: reserveConfigFromFile.protocolLiquidationFeePct,
-    assetTier: reserveConfigFromFile.assetTier,
-    maxLiquidationBonusBps: reserveConfigFromFile.maxLiquidationBonusBps,
-    badDebtLiquidationBonusBps: reserveConfigFromFile.badDebtLiquidationBonusBps,
+    status: farmConfigFromFile.status,
+    loanToValuePct: farmConfigFromFile.loanToValuePct,
+    liquidationThresholdPct: farmConfigFromFile.liquidationThresholdPct,
+    minLiquidationBonusBps: farmConfigFromFile.minLiquidationBonusBps,
+    protocolLiquidationFeePct: farmConfigFromFile.protocolLiquidationFeePct,
+    protocolTakeRatePct: farmConfigFromFile.protocolLiquidationFeePct,
+    assetTier: farmConfigFromFile.assetTier,
+    maxLiquidationBonusBps: farmConfigFromFile.maxLiquidationBonusBps,
+    badDebtLiquidationBonusBps: farmConfigFromFile.badDebtLiquidationBonusBps,
     fees: {
-      borrowFeeSf: Fraction.fromDecimal(new Decimal(reserveConfigFromFile.fees.borrowFee)).valueSf,
-      flashLoanFeeSf: Fraction.fromDecimal(new Decimal(reserveConfigFromFile.fees.flashLoanFee)).valueSf,
+      borrowFeeSf: Fraction.fromDecimal(new Decimal(farmConfigFromFile.fees.borrowFee)).valueSf,
+      flashLoanFeeSf: Fraction.fromDecimal(new Decimal(farmConfigFromFile.fees.flashLoanFee)).valueSf,
       padding: Array(8).fill(0),
     },
-    depositLimit: new BN(reserveConfigFromFile.depositLimit),
-    borrowLimit: new BN(reserveConfigFromFile.borrowLimit),
+    depositLimit: new BN(farmConfigFromFile.depositLimit),
+    borrowLimit: new BN(farmConfigFromFile.borrowLimit),
     tokenInfo: {
-      name: encodeTokenName(reserveConfigFromFile.tokenInfo.name),
+      name: encodeTokenName(farmConfigFromFile.tokenInfo.name),
       heuristic: new PriceHeuristic({
-        lower: new BN(reserveConfigFromFile.tokenInfo.heuristic.lower),
-        upper: new BN(reserveConfigFromFile.tokenInfo.heuristic.upper),
-        exp: new BN(reserveConfigFromFile.tokenInfo.heuristic.exp),
+        lower: new BN(farmConfigFromFile.tokenInfo.heuristic.lower),
+        upper: new BN(farmConfigFromFile.tokenInfo.heuristic.upper),
+        exp: new BN(farmConfigFromFile.tokenInfo.heuristic.exp),
       }),
-      maxTwapDivergenceBps: new BN(reserveConfigFromFile.tokenInfo.maxTwapDivergenceBps),
-      maxAgePriceSeconds: new BN(reserveConfigFromFile.tokenInfo.maxAgePriceSeconds),
-      maxAgeTwapSeconds: new BN(reserveConfigFromFile.tokenInfo.maxAgeTwapSeconds),
-      ...parseOracleConfiguration(reserveConfigFromFile),
-      blockPriceUsage: reserveConfigFromFile.tokenInfo.blockPriceUsage,
+      maxTwapDivergenceBps: new BN(farmConfigFromFile.tokenInfo.maxTwapDivergenceBps),
+      maxAgePriceSeconds: new BN(farmConfigFromFile.tokenInfo.maxAgePriceSeconds),
+      maxAgeTwapSeconds: new BN(farmConfigFromFile.tokenInfo.maxAgeTwapSeconds),
+      ...parseOracleConfiguration(farmConfigFromFile),
+      blockPriceUsage: farmConfigFromFile.tokenInfo.blockPriceUsage,
       reserved: Array(7).fill(0),
       padding: Array(19).fill(new BN(0)),
     } as TokenInfo,
-    borrowRateCurve: parseBorrowRateCurve(reserveConfigFromFile),
+    borrowRateCurve: parseBorrowRateCurve(farmConfigFromFile),
     depositWithdrawalCap: new WithdrawalCaps({
-      configCapacity: new BN(reserveConfigFromFile.depositWithdrawalCap.configCapacity),
+      configCapacity: new BN(farmConfigFromFile.depositWithdrawalCap.configCapacity),
       currentTotal: new BN(0),
       lastIntervalStartTimestamp: new BN(0),
-      configIntervalLengthSeconds: new BN(reserveConfigFromFile.depositWithdrawalCap.configIntervalLengthSeconds),
+      configIntervalLengthSeconds: new BN(farmConfigFromFile.depositWithdrawalCap.configIntervalLengthSeconds),
     }),
     debtWithdrawalCap: new WithdrawalCaps({
-      configCapacity: new BN(reserveConfigFromFile.debtWithdrawalCap.configCapacity),
+      configCapacity: new BN(farmConfigFromFile.debtWithdrawalCap.configCapacity),
       currentTotal: new BN(0),
       lastIntervalStartTimestamp: new BN(0),
-      configIntervalLengthSeconds: new BN(reserveConfigFromFile.debtWithdrawalCap.configIntervalLengthSeconds),
+      configIntervalLengthSeconds: new BN(farmConfigFromFile.debtWithdrawalCap.configIntervalLengthSeconds),
     }),
-    deleveragingMarginCallPeriodSecs: new BN(reserveConfigFromFile.deleveragingMarginCallPeriodSecs),
-    borrowFactorPct: new BN(reserveConfigFromFile.borrowFactorPct),
-    elevationGroups: reserveConfigFromFile.elevationGroups,
-    deleveragingThresholdDecreaseBpsPerDay: new BN(reserveConfigFromFile.deleveragingThresholdDecreaseBpsPerDay),
-    disableUsageAsCollOutsideEmode: reserveConfigFromFile.disableUsageAsCollOutsideEmode,
-    utilizationLimitBlockBorrowingAbovePct: reserveConfigFromFile.utilizationLimitBlockBorrowingAbovePct,
-    hostFixedInterestRateBps: reserveConfigFromFile.hostFixedInterestRateBps,
-    autodeleverageEnabled: reserveConfigFromFile.autodeleverageEnabled,
-    borrowLimitOutsideElevationGroup: new BN(reserveConfigFromFile.borrowLimitOutsideElevationGroup),
-    borrowLimitAgainstThisCollateralInElevationGroup: parseReserveBorrowLimitAgainstCollInEmode(reserveConfigFromFile),
-    deleveragingBonusIncreaseBpsPerDay: new BN(reserveConfigFromFile.deleveragingBonusIncreaseBpsPerDay),
-    reserved1: Array(1).fill(0),
+    deleveragingMarginCallPeriodSecs: new BN(farmConfigFromFile.deleveragingMarginCallPeriodSecs),
+    borrowFactorPct: new BN(farmConfigFromFile.borrowFactorPct),
+    elevationGroups: farmConfigFromFile.elevationGroups,
+    deleveragingThresholdDecreaseBpsPerDay: new BN(farmConfigFromFile.deleveragingThresholdDecreaseBpsPerDay),
+    disableUsageAsCollOutsideEmode: farmConfigFromFile.disableUsageAsCollOutsideEmode,
+    utilizationLimitBlockBorrowingAbovePct: farmConfigFromFile.utilizationLimitBlockBorrowingAbovePct,
+    hostFixedInterestRateBps: farmConfigFromFile.hostFixedInterestRateBps,
+    autodeleverageEnabled: farmConfigFromFile.autodeleverageEnabled,
+    borrowLimitOutsideElevationGroup: new BN(farmConfigFromFile.borrowLimitOutsideElevationGroup),
+    borrowLimitAgainstThisCollateralInElevationGroup: parseReserveBorrowLimitAgainstCollInEmode(farmConfigFromFile),
+    deleveragingBonusIncreaseBpsPerDay: new BN(farmConfigFromFile.deleveragingBonusIncreaseBpsPerDay),
+    reserved1: Array(2).fill(0),
     reserved2: Array(2).fill(0),
     reserved3: Array(8).fill(0),
   };
@@ -1385,29 +1492,29 @@ function parseReserveConfigFromFile(reserveConfigFromFile: any): ReserveConfig {
   return new ReserveConfig(reserveConfigFields);
 }
 
-function parseOracleConfiguration(reserveConfigFromFile: any): {
+function parseOracleConfiguration(farmConfigFromFile: any): {
   pythConfiguration: PythConfiguration;
   switchboardConfiguration: SwitchboardConfiguration;
   scopeConfiguration: ScopeConfiguration;
 } {
   const pythConfiguration = new PythConfiguration({
-    price: new PublicKey(reserveConfigFromFile.tokenInfo.pythConfiguration.price),
+    price: new PublicKey(farmConfigFromFile.tokenInfo.pythConfiguration.price),
   });
   const switchboardConfiguration = new SwitchboardConfiguration({
-    priceAggregator: new PublicKey(reserveConfigFromFile.tokenInfo.switchboardConfiguration.priceAggregator),
-    twapAggregator: new PublicKey(reserveConfigFromFile.tokenInfo.switchboardConfiguration.twapAggregator),
+    priceAggregator: new PublicKey(farmConfigFromFile.tokenInfo.switchboardConfiguration.priceAggregator),
+    twapAggregator: new PublicKey(farmConfigFromFile.tokenInfo.switchboardConfiguration.twapAggregator),
   });
   const priceChain = [65535, 65535, 65535, 65535];
   const twapChain = [65535, 65535, 65535, 65535];
 
-  const priceChainFromFile: number[] = reserveConfigFromFile.tokenInfo.scopeConfiguration.priceChain;
-  const twapChainFromFile: number[] = reserveConfigFromFile.tokenInfo.scopeConfiguration.twapChain;
+  const priceChainFromFile: number[] = farmConfigFromFile.tokenInfo.scopeConfiguration.priceChain;
+  const twapChainFromFile: number[] = farmConfigFromFile.tokenInfo.scopeConfiguration.twapChain;
 
   priceChainFromFile.forEach((value, index) => (priceChain[index] = value));
   twapChainFromFile.forEach((value, index) => (twapChain[index] = value));
 
   const scopeConfiguration = new ScopeConfiguration({
-    priceFeed: new PublicKey(reserveConfigFromFile.tokenInfo.scopeConfiguration.priceFeed),
+    priceFeed: new PublicKey(farmConfigFromFile.tokenInfo.scopeConfiguration.priceFeed),
     priceChain: priceChain,
     twapChain: twapChain,
   });
@@ -1419,29 +1526,29 @@ function parseOracleConfiguration(reserveConfigFromFile: any): {
   };
 }
 
-function parseBorrowRateCurve(reserveConfigFromFile: any): BorrowRateCurve {
+function parseBorrowRateCurve(farmConfigFromFile: any): BorrowRateCurve {
   const curvePoints: CurvePointFields[] = [];
 
-  reserveConfigFromFile.borrowRateCurve.points.forEach((curvePoint: { utilizationRateBps: any; borrowRateBps: any }) =>
+  farmConfigFromFile.borrowRateCurve.points.forEach((curvePoint: { utilizationRateBps: any; borrowRateBps: any }) =>
     curvePoints.push({
       utilizationRateBps: curvePoint.utilizationRateBps,
       borrowRateBps: curvePoint.borrowRateBps,
     })
   );
 
-  const finalCurvePoints: CurvePointFields[] = Array(11).fill(curvePoints[curvePoints.length - 1]);
+  const finalCruvePoints: CurvePointFields[] = Array(11).fill(curvePoints[curvePoints.length - 1]);
 
-  curvePoints.forEach((curvePoint, index) => (finalCurvePoints[index] = curvePoint));
+  curvePoints.forEach((curvePoint, index) => (finalCruvePoints[index] = curvePoint));
 
-  const borrowRateCurve = new BorrowRateCurve({ points: finalCurvePoints });
+  const borrowRateCurve = new BorrowRateCurve({ points: finalCruvePoints });
 
   return borrowRateCurve;
 }
 
-function parseReserveBorrowLimitAgainstCollInEmode(reserveConfigFromFile: any): BN[] {
+function parseReserveBorrowLimitAgainstCollInEmode(farmConfigFromFile: any): BN[] {
   const reserveBorrowLimitAgainstCollInEmode: BN[] = Array(32).fill(new BN(0));
 
-  reserveConfigFromFile.borrowLimitAgainstThisCollateralInElevationGroup.forEach(
+  farmConfigFromFile.borrowLimitAgainstThisCollateralInElevationGroup.forEach(
     (limit: any, index: number) => (reserveBorrowLimitAgainstCollInEmode[index] = new BN(limit))
   );
 

package/src/idl_codegen_kamino_vault/accounts/VaultState.ts

@@ -24,6 +24,7 @@ export interface VaultStateFields {
   prevAumSf: BN
   pendingFeesSf: BN
   vaultAllocationStrategy: Array<types.VaultAllocationFields>
+  padding1: Array<BN>
   minDepositAmount: BN
   minWithdrawAmount: BN
   minInvestAmount: BN
@@ -37,9 +38,9 @@ export interface VaultStateFields {
   vaultLookupTable: PublicKey
   vaultFarm: PublicKey
   creationTimestamp: BN
-  padding1: BN
+  padding2: BN
   allocationAdmin: PublicKey
-  padding2: Array<BN>
+  padding3: Array<BN>
 }
 
 export interface VaultStateJSON {
@@ -62,6 +63,7 @@ export interface VaultStateJSON {
   prevAumSf: string
   pendingFeesSf: string
   vaultAllocationStrategy: Array<types.VaultAllocationJSON>
+  padding1: Array<string>
   minDepositAmount: string
   minWithdrawAmount: string
   minInvestAmount: string
@@ -75,9 +77,9 @@ export interface VaultStateJSON {
   vaultLookupTable: string
   vaultFarm: string
   creationTimestamp: string
-  padding1: string
+  padding2: string
   allocationAdmin: string
-  padding2: Array<string>
+  padding3: Array<string>
 }
 
 export class VaultState {
@@ -100,6 +102,7 @@ export class VaultState {
   readonly prevAumSf: BN
   readonly pendingFeesSf: BN
   readonly vaultAllocationStrategy: Array<types.VaultAllocation>
+  readonly padding1: Array<BN>
   readonly minDepositAmount: BN
   readonly minWithdrawAmount: BN
   readonly minInvestAmount: BN
@@ -113,9 +116,9 @@ export class VaultState {
   readonly vaultLookupTable: PublicKey
   readonly vaultFarm: PublicKey
   readonly creationTimestamp: BN
-  readonly padding1: BN
+  readonly padding2: BN
   readonly allocationAdmin: PublicKey
-  readonly padding2: Array<BN>
+  readonly padding3: Array<BN>
 
   static readonly discriminator = Buffer.from([
     228, 196, 82, 165, 98, 210, 235, 152,
@@ -140,7 +143,8 @@ export class VaultState {
     borsh.u64("lastFeeChargeTimestamp"),
     borsh.u128("prevAumSf"),
     borsh.u128("pendingFeesSf"),
-    borsh.array(types.VaultAllocation.layout(), 10, "vaultAllocationStrategy"),
+    borsh.array(types.VaultAllocation.layout(), 25, "vaultAllocationStrategy"),
+    borsh.array(borsh.u128(), 256, "padding1"),
     borsh.u64("minDepositAmount"),
     borsh.u64("minWithdrawAmount"),
     borsh.u64("minInvestAmount"),
@@ -154,9 +158,9 @@ export class VaultState {
     borsh.publicKey("vaultLookupTable"),
     borsh.publicKey("vaultFarm"),
     borsh.u64("creationTimestamp"),
-    borsh.u64("padding1"),
+    borsh.u64("padding2"),
     borsh.publicKey("allocationAdmin"),
-    borsh.array(borsh.u128(), 242, "padding2"),
+    borsh.array(borsh.u128(), 242, "padding3"),
   ])
 
   constructor(fields: VaultStateFields) {
@@ -181,6 +185,7 @@ export class VaultState {
     this.vaultAllocationStrategy = fields.vaultAllocationStrategy.map(
       (item) => new types.VaultAllocation({ ...item })
     )
+    this.padding1 = fields.padding1
     this.minDepositAmount = fields.minDepositAmount
     this.minWithdrawAmount = fields.minWithdrawAmount
     this.minInvestAmount = fields.minInvestAmount
@@ -194,9 +199,9 @@ export class VaultState {
     this.vaultLookupTable = fields.vaultLookupTable
     this.vaultFarm = fields.vaultFarm
     this.creationTimestamp = fields.creationTimestamp
-    this.padding1 = fields.padding1
-    this.allocationAdmin = fields.allocationAdmin
     this.padding2 = fields.padding2
+    this.allocationAdmin = fields.allocationAdmin
+    this.padding3 = fields.padding3
   }
 
   static async fetch(
@@ -266,6 +271,7 @@ export class VaultState {
           item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
         ) => types.VaultAllocation.fromDecoded(item)
       ),
+      padding1: dec.padding1,
       minDepositAmount: dec.minDepositAmount,
       minWithdrawAmount: dec.minWithdrawAmount,
       minInvestAmount: dec.minInvestAmount,
@@ -279,9 +285,9 @@ export class VaultState {
       vaultLookupTable: dec.vaultLookupTable,
       vaultFarm: dec.vaultFarm,
       creationTimestamp: dec.creationTimestamp,
-      padding1: dec.padding1,
-      allocationAdmin: dec.allocationAdmin,
       padding2: dec.padding2,
+      allocationAdmin: dec.allocationAdmin,
+      padding3: dec.padding3,
     })
   }
 
@@ -308,6 +314,7 @@ export class VaultState {
       vaultAllocationStrategy: this.vaultAllocationStrategy.map((item) =>
         item.toJSON()
       ),
+      padding1: this.padding1.map((item) => item.toString()),
       minDepositAmount: this.minDepositAmount.toString(),
       minWithdrawAmount: this.minWithdrawAmount.toString(),
       minInvestAmount: this.minInvestAmount.toString(),
@@ -321,9 +328,9 @@ export class VaultState {
       vaultLookupTable: this.vaultLookupTable.toString(),
       vaultFarm: this.vaultFarm.toString(),
       creationTimestamp: this.creationTimestamp.toString(),
-      padding1: this.padding1.toString(),
+      padding2: this.padding2.toString(),
       allocationAdmin: this.allocationAdmin.toString(),
-      padding2: this.padding2.map((item) => item.toString()),
+      padding3: this.padding3.map((item) => item.toString()),
     }
   }
 
@@ -350,6 +357,7 @@ export class VaultState {
       vaultAllocationStrategy: obj.vaultAllocationStrategy.map((item) =>
         types.VaultAllocation.fromJSON(item)
       ),
+      padding1: obj.padding1.map((item) => new BN(item)),
       minDepositAmount: new BN(obj.minDepositAmount),
       minWithdrawAmount: new BN(obj.minWithdrawAmount),
       minInvestAmount: new BN(obj.minInvestAmount),
@@ -363,9 +371,9 @@ export class VaultState {
       vaultLookupTable: new PublicKey(obj.vaultLookupTable),
       vaultFarm: new PublicKey(obj.vaultFarm),
       creationTimestamp: new BN(obj.creationTimestamp),
-      padding1: new BN(obj.padding1),
+      padding2: new BN(obj.padding2),
       allocationAdmin: new PublicKey(obj.allocationAdmin),
-      padding2: obj.padding2.map((item) => new BN(item)),
+      padding3: obj.padding3.map((item) => new BN(item)),
     })
   }
 }

package/src/idl_codegen_kamino_vault/errors/custom.ts

@@ -46,6 +46,7 @@ export type CustomError =
   | MinWithdrawAmountTooBig
   | InvestTooSoon
   | WrongAdminOrAllocationAdmin
+  | ReserveHasNonZeroAllocationOrCTokens
 
 export class DepositAmountsZero extends Error {
   static readonly code = 7000
@@ -564,6 +565,20 @@ export class WrongAdminOrAllocationAdmin extends Error {
   }
 }
 
+export class ReserveHasNonZeroAllocationOrCTokens extends Error {
+  static readonly code = 7047
+  readonly code = 7047
+  readonly name = "ReserveHasNonZeroAllocationOrCTokens"
+  readonly msg =
+    "Reserve has non-zero allocation or ctokens so cannot be removed"
+
+  constructor(readonly logs?: string[]) {
+    super(
+      "7047: Reserve has non-zero allocation or ctokens so cannot be removed"
+    )
+  }
+}
+
 export function fromCode(code: number, logs?: string[]): CustomError | null {
   switch (code) {
     case 7000:
@@ -660,6 +675,8 @@ export function fromCode(code: number, logs?: string[]): CustomError | null {
       return new InvestTooSoon(logs)
     case 7046:
       return new WrongAdminOrAllocationAdmin(logs)
+    case 7047:
+      return new ReserveHasNonZeroAllocationOrCTokens(logs)
   }
 
   return null

package/src/idl_codegen_kamino_vault/instructions/index.ts

@@ -40,3 +40,5 @@ export type {
   WithdrawFromAvailableArgs,
   WithdrawFromAvailableAccounts,
 } from "./withdrawFromAvailable"
+export { removeAllocation } from "./removeAllocation"
+export type { RemoveAllocationAccounts } from "./removeAllocation"

package/src/idl_codegen_kamino_vault/instructions/removeAllocation.ts

@@ -0,0 +1,26 @@
+import { TransactionInstruction, PublicKey, AccountMeta } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface RemoveAllocationAccounts {
+  vaultAdminAuthority: PublicKey
+  vaultState: PublicKey
+  reserve: PublicKey
+}
+
+export function removeAllocation(
+  accounts: RemoveAllocationAccounts,
+  programId: PublicKey = PROGRAM_ID
+) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.vaultAdminAuthority, isSigner: true, isWritable: true },
+    { pubkey: accounts.vaultState, isSigner: false, isWritable: true },
+    { pubkey: accounts.reserve, isSigner: false, isWritable: false },
+  ]
+  const identifier = Buffer.from([32, 220, 211, 141, 209, 231, 73, 76])
+  const data = identifier
+  const ix = new TransactionInstruction({ keys, programId, data })
+  return ix
+}

package/src/idl_codegen_kamino_vault/programId.ts

@@ -2,13 +2,12 @@ import { PublicKey } from "@solana/web3.js"
 
 // Program ID passed with the cli --program-id flag when running the code generator. Do not edit, it will get overwritten.
 export const KVAULTS_PROGRAM_ID_CLI = new PublicKey(
-  "kvauTFR8qm1dhniz6pYuBZkuene3Hfrs1VQhVRgCNrr"
+  "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd"
 )
 
 // This constant will not get overwritten on subsequent code generations and it's safe to modify it's value.
 export let KVAULTS_PROGRAM_ID: PublicKey = KVAULTS_PROGRAM_ID_CLI
 export let PROGRAM_ID: PublicKey = KVAULTS_PROGRAM_ID_CLI
-
 export const setKVaultsProgramId = (programId: PublicKey) => {
   KVAULTS_PROGRAM_ID = programId;
   PROGRAM_ID = programId;