@kamino-finance/klend-sdk 5.0.4 → 5.0.5

package/src/classes/market.ts

@@ -31,9 +31,11 @@ import bs58 from 'bs58';
 import { OraclePrices, Scope } from '@kamino-finance/scope-sdk';
 import { Fraction } from './fraction';
 import { chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
-import { parseTokenSymbol } from './utils';
+import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
 import SwitchboardProgram from '@switchboard-xyz/sbv2-lite';
 import { ObligationZP } from '../idl_codegen/zero_padding';
+import { ReserveStatus } from '../idl_codegen/types';
+import { getProgramAccounts } from '../utils/rpc';
 
 export interface ReserveRewardInfo {
   rewardsPerSecond: Decimal; // not lamport
@@ -84,8 +86,11 @@ export class KaminoMarket {
    * Load a new market with all of its associated reserves
    * @param connection
    * @param marketAddress
+   * @param recentSlotDurationMs
    * @param programId
+   * @param withReserves
    * @param setupLocalTest
+   * @param withReserves
    */
   static async load(
     connection: Connection,
@@ -175,6 +180,10 @@ export class KaminoMarket {
     return lendingMarketAuthPda(this.getAddress(), this.programId)[0];
   }
 
+  getName(): string {
+    return parseZeroPaddedUtf8(this.state.name);
+  }
+
   async getObligationDepositByWallet(
     owner: PublicKey,
     mint: PublicKey,
@@ -524,7 +533,6 @@ export class KaminoMarket {
    * @param tag
    */
   async getAllObligationsForMarket(tag?: number): Promise<KaminoObligation[]> {
-    const { getProgramAccounts } = await import('../utils/rpc');
     const filters = [
       {
         dataSize: Obligation.layout.span + 8,
@@ -1082,6 +1090,10 @@ export class KaminoMarket {
     const spot: MintToPriceMap = {};
     const twaps: MintToPriceMap = {};
     for (const reserve of this.reserves.values()) {
+      if (reserve.state.config.status === ReserveStatus.Obsolete.discriminator) {
+        // skip obsolete reserves
+        continue;
+      }
       const tokenMint = reserve.getLiquidityMint().toString();
       const tokenName = reserve.getTokenSymbol();
       const oracle = reserve.state.config.tokenInfo.scopeConfiguration.priceFeed;
@@ -1119,6 +1131,11 @@ export class KaminoMarket {
     const switchboardV2 = await SwitchboardProgram.loadMainnet(this.connection);
 
     for (const reserve of this.reserves.values()) {
+      if (reserve.state.config.status === ReserveStatus.Obsolete.discriminator) {
+        // skip obsolete reserves
+        continue;
+      }
+
       const tokenMint = reserve.getLiquidityMint().toString();
       const tokenName = reserve.getTokenSymbol();
       const scopeOracle = reserve.state.config.tokenInfo.scopeConfiguration.priceFeed;

package/src/classes/obligation.ts

@@ -366,7 +366,7 @@ export class KaminoObligation {
       if (obligationDeposits[i].depositReserve.equals(changeReserve)) {
         const coll: ObligationCollateralFields = { ...obligationDeposits[i] };
         const exchangeRate = collateralExchangeRates.get(changeReserve)!;
-        const changeInCollateral = new Decimal(changeInLamports).mul(exchangeRate);
+        const changeInCollateral = new Decimal(changeInLamports).mul(exchangeRate).toFixed(0);
         const updatedDeposit = new Decimal(obligationDeposits[i].depositedAmount.toNumber()).add(changeInCollateral);
         coll.depositedAmount = new BN(positiveOrZero(updatedDeposit).toString());
         newDeposits.push(new ObligationCollateral(coll));
@@ -927,6 +927,7 @@ export class KaminoObligation {
     if (elevationGroup === this.state.elevationGroup) {
       return Decimal.min(maxBorrowAmount, liquidityAvailable);
     } else {
+      // TODO: this is wrong, most liquidity caps are global, we should add up only the ones that are specific to this mode
       const { amount: debtThisReserve } = this.borrows.get(reserve.address) || { amount: new Decimal(0) };
       const liquidityAvailablePostMigration = Decimal.max(0, liquidityAvailable.minus(debtThisReserve));
       return Decimal.min(maxBorrowAmount, liquidityAvailablePostMigration);

package/src/classes/reserve.ts

@@ -23,7 +23,14 @@ import {
 import { FeeCalculation, Fees, ReserveDataType, ReserveFarmInfo, ReserveRewardYield, ReserveStatus } from './shared';
 import { Reserve, ReserveFields } from '../idl_codegen/accounts';
 import { BorrowRateCurve, CurvePointFields, ReserveConfig, UpdateConfigMode } from '../idl_codegen/types';
-import { calculateAPYFromAPR, getBorrowRate, lamportsToNumberDecimal, parseTokenSymbol, positiveOrZero } from './utils';
+import {
+  calculateAPYFromAPR,
+  getBorrowRate,
+  lamportsToNumberDecimal,
+  parseTokenSymbol,
+  positiveOrZero,
+  sameLengthArrayEquals,
+} from './utils';
 import { Fraction } from './fraction';
 import BN from 'bn.js';
 import { ActionType } from './action';
@@ -570,7 +577,7 @@ export class KaminoReserve {
     return Decimal.max(new Decimal(0), maxBorrowAmount);
   }
 
-  calcSimulatedBorrowAPR(
+  calcSimulatedBorrowRate(
     amount: Decimal,
     action: ActionType,
     slot: number,
@@ -580,7 +587,20 @@ export class KaminoReserve {
     const slotAdjustmentFactor = this.slotAdjustmentFactor();
     const newUtilization = this.calcSimulatedUtilizationRatio(amount, action, slot, referralFeeBps, outflowAmount);
     const curve = truncateBorrowCurve(this.state.config.borrowRateCurve.points);
-    return getBorrowRate(newUtilization, curve) * slotAdjustmentFactor + this.getFixedHostInterestRate().toNumber();
+    return getBorrowRate(newUtilization, curve) * slotAdjustmentFactor;
+  }
+
+  calcSimulatedBorrowAPR(
+    amount: Decimal,
+    action: ActionType,
+    slot: number,
+    referralFeeBps: number,
+    outflowAmount?: Decimal
+  ) {
+    return (
+      this.calcSimulatedBorrowRate(amount, action, slot, referralFeeBps, outflowAmount) +
+      this.getFixedHostInterestRate().toNumber()
+    );
   }
 
   calcSimulatedSupplyAPR(
@@ -591,7 +611,7 @@ export class KaminoReserve {
     outflowAmount?: Decimal
   ) {
     const newUtilization = this.calcSimulatedUtilizationRatio(amount, action, slot, referralFeeBps, outflowAmount);
-    const simulatedBorrowAPR = this.calcSimulatedBorrowAPR(amount, action, slot, referralFeeBps, outflowAmount);
+    const simulatedBorrowAPR = this.calcSimulatedBorrowRate(amount, action, slot, referralFeeBps, outflowAmount);
     const protocolTakeRatePct = 1 - this.state.config.protocolTakeRatePct / 100;
 
     return newUtilization * simulatedBorrowAPR * protocolTakeRatePct;
@@ -1746,17 +1766,11 @@ export function parseForChangesReserveConfigAndGetIxs(
           ),
         });
       } else {
-        for (let i = 0; i < tokenInfo.name.length; i++) {
-          if (reserve.config.tokenInfo.name[i] !== tokenInfo.name[i]) {
-            updateReserveIxnsArgs.push({
-              mode: UpdateConfigMode.UpdateTokenInfoName.discriminator,
-              value: updateReserveConfigEncodedValue(
-                UpdateConfigMode.UpdateTokenInfoName.discriminator,
-                tokenInfo.name
-              ),
-            });
-            break;
-          }
+        if (!sameLengthArrayEquals(reserve.config.tokenInfo.name, tokenInfo.name)) {
+          updateReserveIxnsArgs.push({
+            mode: UpdateConfigMode.UpdateTokenInfoName.discriminator,
+            value: updateReserveConfigEncodedValue(UpdateConfigMode.UpdateTokenInfoName.discriminator, tokenInfo.name),
+          });
         }
         if (!reserve.config.tokenInfo.heuristic.lower.eq(tokenInfo.heuristic.lower)) {
           updateReserveIxnsArgs.push({
@@ -1812,31 +1826,33 @@ export function parseForChangesReserveConfigAndGetIxs(
             ),
           });
         }
-        for (let i = 0; i < tokenInfo.scopeConfiguration.priceChain.length; i++) {
-          if (
-            reserve.config.tokenInfo.scopeConfiguration.priceChain[i] !== tokenInfo.scopeConfiguration.priceChain[i]
-          ) {
-            updateReserveIxnsArgs.push({
-              mode: UpdateConfigMode.UpdateTokenInfoScopeChain.discriminator,
-              value: updateReserveConfigEncodedValue(
-                UpdateConfigMode.UpdateTokenInfoScopeChain.discriminator,
-                tokenInfo.scopeConfiguration.priceChain
-              ),
-            });
-            break;
-          }
+        if (
+          !sameLengthArrayEquals(
+            reserve.config.tokenInfo.scopeConfiguration.priceChain,
+            tokenInfo.scopeConfiguration.priceChain
+          )
+        ) {
+          updateReserveIxnsArgs.push({
+            mode: UpdateConfigMode.UpdateTokenInfoScopeChain.discriminator,
+            value: updateReserveConfigEncodedValue(
+              UpdateConfigMode.UpdateTokenInfoScopeChain.discriminator,
+              tokenInfo.scopeConfiguration.priceChain
+            ),
+          });
         }
-        for (let i = 0; i < tokenInfo.scopeConfiguration.twapChain.length; i++) {
-          if (reserve.config.tokenInfo.scopeConfiguration.twapChain[i] !== tokenInfo.scopeConfiguration.twapChain[i]) {
-            updateReserveIxnsArgs.push({
-              mode: UpdateConfigMode.UpdateTokenInfoScopeTwap.discriminator,
-              value: updateReserveConfigEncodedValue(
-                UpdateConfigMode.UpdateTokenInfoScopeTwap.discriminator,
-                tokenInfo.scopeConfiguration.twapChain
-              ),
-            });
-            break;
-          }
+        if (
+          !sameLengthArrayEquals(
+            reserve.config.tokenInfo.scopeConfiguration.twapChain,
+            tokenInfo.scopeConfiguration.twapChain
+          )
+        ) {
+          updateReserveIxnsArgs.push({
+            mode: UpdateConfigMode.UpdateTokenInfoScopeTwap.discriminator,
+            value: updateReserveConfigEncodedValue(
+              UpdateConfigMode.UpdateTokenInfoScopeTwap.discriminator,
+              tokenInfo.scopeConfiguration.twapChain
+            ),
+          });
         }
         if (
           !reserve.config.tokenInfo.switchboardConfiguration.priceAggregator.equals(

package/src/classes/utils.ts

@@ -142,6 +142,29 @@ export const parseTokenSymbol = (tokenSymbol: number[]): string => {
   return String.fromCharCode(...tokenSymbol.filter((x) => x > 0));
 };
 
+export function parseZeroPaddedUtf8(utf8Array: number[]): string {
+  for (let last = utf8Array.length - 1; last >= 0; last--) {
+    const trailing_zero = utf8Array[last];
+    if (trailing_zero != 0) {
+      const encoding = new Uint8Array(last + 1);
+      for (let i = 0; i <= last; i++) {
+        encoding[i] = utf8Array[i];
+      }
+      break;
+    }
+  }
+  return new TextDecoder().decode();
+}
+
+export function renderZeroPaddedUtf8(str: string, utf8ArrayLength: number): number[] {
+  const encoding = new TextEncoder().encode(str);
+  const result = new Array<number>(utf8ArrayLength);
+  for (let i = 0; i < result.length; i++) {
+    result[i] = i < encoding.length ? encoding[i] : 0;
+  }
+  return result;
+}
+
 export function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -190,3 +213,10 @@ export function calculateAPRFromAPY(apy: Decimal.Value) {
     .minus(1)
     .times(SLOTS_PER_YEAR);
 }
+
+export function sameLengthArrayEquals(left: Array<number>, right: Array<number>): boolean {
+  if (left.length != right.length) {
+    throw new Error(`Not same length: ${left.length} != ${left.length}`);
+  }
+  return left.every((value, index) => value === right[index]);
+}

package/src/classes/vault.ts

@@ -23,6 +23,8 @@ import {
   WRAPPED_SOL_MINT,
 } from '../lib';
 import {
+  // closeVault,
+  // CloseVaultAccounts,
   DepositAccounts,
   DepositArgs,
   initVault,
@@ -44,6 +46,8 @@ import { PROGRAM_ID } from '../idl_codegen/programId';
 import { DEFAULT_RECENT_SLOT_DURATION_MS, ReserveWithAddress } from './reserve';
 import { Fraction } from './fraction';
 import { lendingMarketAuthPda } from '../utils/seeds';
+import bs58 from 'bs58';
+import { getProgramAccounts } from '../utils/rpc';
 
 export const kaminoVaultId = new PublicKey('kvauTFR8qm1dhniz6pYuBZkuene3Hfrs1VQhVRgCNrr');
 
@@ -124,6 +128,7 @@ export class KaminoVaultClient {
       systemProgram: SystemProgram.programId,
       rent: SYSVAR_RENT_PUBKEY,
       tokenProgram: vaultConfig.tokenMintProgramId,
+      sharesTokenProgram: TOKEN_PROGRAM_ID,
     };
     const initVaultIx = initVault(initVaultAccounts, this._kaminoVaultProgramId);
 
@@ -145,7 +150,11 @@ export class KaminoVaultClient {
     const vaultState: VaultState = await vault.getState(this.getConnection());
     const reserveState: Reserve = reserveAllocationConfig.getReserveState();
 
-    const cTokenVault = getCTokenVaultPda(reserveAllocationConfig.getReserveAddress(), this._kaminoVaultProgramId);
+    const cTokenVault = getCTokenVaultPda(
+      vault.address,
+      reserveAllocationConfig.getReserveAddress(),
+      this._kaminoVaultProgramId
+    );
 
     const updateReserveAllocationAccounts: UpdateReserveAllocationAccounts = {
       adminAuthority: vaultState.adminAuthority,
@@ -171,6 +180,17 @@ export class KaminoVaultClient {
     );
   }
 
+  // async closeVaultIx(vault: KaminoVault): Promise<TransactionInstruction> {
+  //   const vaultState: VaultState = await vault.getState(this.getConnection());
+
+  //   const closeVaultAccounts: CloseVaultAccounts = {
+  //     adminAuthority: vaultState.adminAuthority,
+  //     vaultState: vault.address,
+  //   };
+
+  //   return closeVault(closeVaultAccounts, this._kaminoVaultProgramId);
+  // }
+
   /**
    * This function creates instructions to deposit into a vault. It will also create ATA creation instructions for the vault shares that the user receives in return
    * @param user - user to deposit
@@ -225,6 +245,8 @@ export class KaminoVaultClient {
       userSharesAta: userSharesAta,
       tokenProgram: TOKEN_PROGRAM_ID,
       instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+      klendProgram: this._kaminoLendProgramId,
+      sharesTokenProgram: TOKEN_PROGRAM_ID,
     };
 
     const depositArgs: DepositArgs = {
@@ -235,10 +257,24 @@ export class KaminoVaultClient {
 
     const vaultReserves = this.getVaultReserves(vaultState);
 
-    const vaultReservesAccountMetas: AccountMeta[] = vaultReserves.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: false };
+    const vaultReservesState = await this.loadVaultReserves(vaultState);
+
+    let vaultReservesAccountMetas: AccountMeta[] = [];
+    let vaultReservesLendingMarkets: AccountMeta[] = [];
+    vaultReserves.forEach((reserve) => {
+      const reserveState = vaultReservesState.get(reserve);
+      if (reserveState === undefined) {
+        throw new Error(`Reserve ${reserve.toBase58()} not found`);
+      }
+      vaultReservesAccountMetas = vaultReservesAccountMetas.concat([
+        { pubkey: reserve, isSigner: false, isWritable: true },
+      ]);
+      vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
+        { pubkey: reserveState.state.lendingMarket, isSigner: false, isWritable: false },
+      ]);
     });
     depositIx.keys = depositIx.keys.concat(vaultReservesAccountMetas);
+    depositIx.keys = depositIx.keys.concat(vaultReservesLendingMarkets);
 
     return [...createAtasIxns, depositIx, ...closeAtasIxns];
   }
@@ -341,7 +377,7 @@ export class KaminoVaultClient {
    * @param kaminoVault - vault to invest from
    * @returns - an array of invest instructions for each invest action required for the vault reserves
    */
-  async investAllReservesIxs(vault: KaminoVault): Promise<TransactionInstruction[]> {
+  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._connection);
@@ -352,7 +388,7 @@ export class KaminoVaultClient {
       if (reserveState === null) {
         throw new Error(`Reserve ${reserve.toBase58()} not found`);
       }
-      investIxns.push(await this.investSingleReserveIxs(vault, { address: reserve, state: reserveState }));
+      investIxns.push(await this.investSingleReserveIxs(payer, vault, { address: reserve, state: reserveState }));
     }
 
     return investIxns;
@@ -364,14 +400,21 @@ export class KaminoVaultClient {
    * @param reserve - reserve to invest into or disinvest from
    * @returns - an array of invest instructions for each invest action required for the vault reserves
    */
-  async investSingleReserveIxs(vault: KaminoVault, reserve: ReserveWithAddress): Promise<TransactionInstruction> {
+  async investSingleReserveIxs(
+    payer: PublicKey,
+    vault: KaminoVault,
+    reserve: ReserveWithAddress
+  ): Promise<TransactionInstruction> {
     const vaultState = await vault.getState(this._connection);
 
-    const cTokenVault = getCTokenVaultPda(reserve.address, this._kaminoVaultProgramId);
+    const cTokenVault = getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId);
     const lendingMarketAuth = lendingMarketAuthPda(reserve.state.lendingMarket, this._kaminoLendProgramId)[0];
 
+    // todo: create ata if needed here
+    const payerTokenAta = getAssociatedTokenAddress(vaultState.tokenMint, payer);
+
     const investAccounts: InvestAccounts = {
-      adminAuthority: vaultState.adminAuthority,
+      payer,
       vaultState: vault.address,
       tokenVault: vaultState.tokenVault,
       baseVaultAuthority: vaultState.baseVaultAuthority,
@@ -385,6 +428,10 @@ export class KaminoVaultClient {
       klendProgram: this._kaminoLendProgramId,
       instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
       tokenProgram: TOKEN_PROGRAM_ID,
+      payerTokenAccount: payerTokenAta,
+      tokenMint: vaultState.tokenMint,
+      reserveCollateralTokenProgram: TOKEN_PROGRAM_ID,
+      sharesTokenProgram: TOKEN_PROGRAM_ID,
     };
 
     const investIx = invest(investAccounts, this._kaminoVaultProgramId);
@@ -398,7 +445,7 @@ export class KaminoVaultClient {
     return investIx;
   }
 
-  private withdrawIxn(
+  private async withdrawIxn(
     user: PublicKey,
     vault: KaminoVault,
     vaultState: VaultState,
@@ -407,7 +454,7 @@ export class KaminoVaultClient {
     userSharesAta: PublicKey,
     userTokenAta: PublicKey,
     shareAmountLamports: Decimal
-  ): TransactionInstruction {
+  ): Promise<TransactionInstruction> {
     const lendingMarketAuth = lendingMarketAuthPda(marketWithAddress.address, this._kaminoLendProgramId)[0];
 
     const withdrawAccounts: WithdrawAccounts = {
@@ -422,13 +469,15 @@ export class KaminoVaultClient {
       tokenProgram: TOKEN_PROGRAM_ID,
       instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
       reserve: reserve.address,
-      ctokenVault: getCTokenVaultPda(reserve.address, this._kaminoVaultProgramId),
+      ctokenVault: getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId),
       /** CPI accounts */
       lendingMarket: marketWithAddress.address,
       lendingMarketAuthority: lendingMarketAuth,
       reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
       reserveCollateralMint: reserve.state.collateral.mintPubkey,
       klendProgram: this._kaminoLendProgramId,
+      reserveCollateralTokenProgram: TOKEN_PROGRAM_ID,
+      sharesTokenProgram: TOKEN_PROGRAM_ID,
     };
 
     const withdrawArgs: WithdrawArgs = {
@@ -438,10 +487,26 @@ export class KaminoVaultClient {
     const withdrawIxn = withdraw(withdrawArgs, withdrawAccounts, this._kaminoVaultProgramId);
 
     const vaultReserves = this.getVaultReserves(vaultState);
-    const vaultReservesAccountMetas: AccountMeta[] = vaultReserves.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: false };
+    const vaultReservesState = await this.loadVaultReserves(vaultState);
+
+    let vaultReservesAccountMetas: AccountMeta[] = [];
+    let vaultReservesLendingMarkets: AccountMeta[] = [];
+
+    vaultReserves.forEach((reserve) => {
+      const reserveState = vaultReservesState.get(reserve);
+      if (reserveState === undefined) {
+        throw new Error(`Reserve ${reserve.toBase58()} not found`);
+      }
+
+      vaultReservesAccountMetas = vaultReservesAccountMetas.concat([
+        { pubkey: reserve, isSigner: false, isWritable: true },
+      ]);
+      vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
+        { pubkey: reserveState.state.lendingMarket, isSigner: false, isWritable: false },
+      ]);
     });
     withdrawIxn.keys = withdrawIxn.keys.concat(vaultReservesAccountMetas);
+    withdrawIxn.keys = withdrawIxn.keys.concat(vaultReservesLendingMarkets);
 
     return withdrawIxn;
   }
@@ -590,6 +655,44 @@ export class KaminoVaultClient {
     return vaultTokensPerShare;
   }
 
+  /**
+   * Get all vaults
+   * @returns an array of all vaults
+   */
+  async getAllVaults(): Promise<KaminoVault[]> {
+    const filters = [
+      {
+        dataSize: VaultState.layout.span + 8,
+      },
+      {
+        memcmp: {
+          offset: 0,
+          bytes: bs58.encode(VaultState.discriminator),
+        },
+      },
+    ];
+
+    const [kaminoVaults] = await Promise.all([
+      getProgramAccounts(this._connection, this._kaminoVaultProgramId, {
+        commitment: this._connection.commitment ?? 'processed',
+        filters,
+      }),
+    ]);
+
+    return kaminoVaults.map((kaminoVault) => {
+      if (kaminoVault.account === null) {
+        throw new Error(`kaminoVault with pubkey ${kaminoVault.pubkey.toString()} does not exist`);
+      }
+
+      const kaminoVaultAccount = VaultState.decode(kaminoVault.account.data);
+      if (!kaminoVaultAccount) {
+        throw Error(`kaminoVault with pubkey ${kaminoVault.pubkey.toString()} could not be decoded`);
+      }
+
+      return new KaminoVault(kaminoVault.pubkey, kaminoVaultAccount, this._kaminoVaultProgramId);
+    });
+  }
+
   /**
    * 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
@@ -673,40 +776,6 @@ export class KaminoVaultClient {
 
     return kaminoReserves;
   }
-
-  /**
-   * Get all vaults
-   * @returns an array of all vaults
-   */
-  async getAllVaults(): Promise<KaminoVault[]> {
-    const { getProgramAccounts } = await import('../utils/rpc');
-    const filters = [
-      {
-        dataSize: VaultState.layout.span + 8,
-      },
-    ];
-
-    const [, kaminoVaults] = await Promise.all([
-      this._connection.getSlot(),
-      getProgramAccounts(this._connection, this._kaminoVaultProgramId, {
-        commitment: this._connection.commitment ?? 'processed',
-        filters,
-      }),
-    ]);
-
-    return kaminoVaults.map((kaminoVault) => {
-      if (kaminoVault.account === null) {
-        throw new Error('Invalid account');
-      }
-
-      const kaminoVaultAccount = VaultState.decode(kaminoVault.account.data);
-      if (!kaminoVaultAccount) {
-        throw Error('Could not parse obligation.');
-      }
-
-      return new KaminoVault(kaminoVault.pubkey, kaminoVaultAccount, this._kaminoVaultProgramId);
-    });
-  }
 } // KaminoVaultClient
 
 export class KaminoVault {
@@ -804,9 +873,14 @@ export class ReserveAllocationConfig {
   }
 }
 
-export function getCTokenVaultPda(reserveAddress: PublicKey, kaminoVaultProgramId: PublicKey) {
+export function getCTokenVaultPda(vaultAddress: PublicKey, reserveAddress: PublicKey, kaminoVaultProgramId: PublicKey) {
   return PublicKey.findProgramAddressSync(
-    [Buffer.from(CTOKEN_VAULT_SEED), reserveAddress.toBytes()],
+    [Buffer.from(CTOKEN_VAULT_SEED), vaultAddress.toBytes(), reserveAddress.toBytes()],
     kaminoVaultProgramId
   )[0];
 }
+
+export type VaultHolder = {
+  holderPubkey: PublicKey;
+  amount: Decimal;
+};

package/src/client_kamino_manager.ts

@@ -87,7 +87,7 @@ async function main() {
 
   commands
     .command('add-asset-to-market')
-    .requiredOption('--market <string>', 'Market addres to add asset to')
+    .requiredOption('--market <string>', 'Market address to add asset to')
     .requiredOption('--mint <string>', 'Reserve liquidity token mint')
     .requiredOption('--mint-program-id <string>', 'Reserve liquidity token mint program id')
     .requiredOption('--reserve-config-path <string>', 'Path for the reserve config')
@@ -296,6 +296,24 @@ async function main() {
       mode === 'execute' && console.log('Vault allocation updated:', updateVaultAllocationSig);
     });
 
+  // commands
+  //   .command('close-vault')
+  //   .requiredOption('--vault <string>', 'Vault address')
+  //   .option(`--staging`, 'If true, will use the staging programs')
+  //   .action(async ({vault, staging}) => {
+  //     console.log("silviuuuu vault", vault);
+  //     const env = initializeClient(false, staging);
+  //     const vaultAddress = new PublicKey(vault);
+
+  //     const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+  //     const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+  //     const instructions = await kaminoManager.closeVault(kaminoVault);
+
+  //     const closeVaultSig = await processTxn(env.client, env.payer, [instructions], 'execute', 2500, []);
+  //     console.log('Vault closed:', closeVaultSig);
+  //   });
+
   commands.command('get-oracle-mappings').action(async () => {
     const env = initializeClient(false, false);
     const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);

package/src/idl_codegen/accounts/LendingMarket.ts

@@ -51,6 +51,8 @@ export interface LendingMarketFields {
   /** Min net value accepted to be found in a position after any lending action in an obligation (scaled by quote currency decimals) */
   minNetValueInObligationSf: BN
   minValueSkipLiquidationLtvBfChecks: BN
+  /** Market name, zero-padded. */
+  name: Array<number>
   padding1: Array<BN>
 }
 
@@ -101,6 +103,8 @@ export interface LendingMarketJSON {
   /** Min net value accepted to be found in a position after any lending action in an obligation (scaled by quote currency decimals) */
   minNetValueInObligationSf: string
   minValueSkipLiquidationLtvBfChecks: string
+  /** Market name, zero-padded. */
+  name: Array<number>
   padding1: Array<string>
 }
 
@@ -151,6 +155,8 @@ export class LendingMarket {
   /** Min net value accepted to be found in a position after any lending action in an obligation (scaled by quote currency decimals) */
   readonly minNetValueInObligationSf: BN
   readonly minValueSkipLiquidationLtvBfChecks: BN
+  /** Market name, zero-padded. */
+  readonly name: Array<number>
   readonly padding1: Array<BN>
 
   static readonly discriminator = Buffer.from([
@@ -180,7 +186,8 @@ export class LendingMarket {
     borsh.array(borsh.u64(), 90, "elevationGroupPadding"),
     borsh.u128("minNetValueInObligationSf"),
     borsh.u64("minValueSkipLiquidationLtvBfChecks"),
-    borsh.array(borsh.u64(), 177, "padding1"),
+    borsh.array(borsh.u8(), 32, "name"),
+    borsh.array(borsh.u64(), 173, "padding1"),
   ])
 
   constructor(fields: LendingMarketFields) {
@@ -212,6 +219,7 @@ export class LendingMarket {
     this.minNetValueInObligationSf = fields.minNetValueInObligationSf
     this.minValueSkipLiquidationLtvBfChecks =
       fields.minValueSkipLiquidationLtvBfChecks
+    this.name = fields.name
     this.padding1 = fields.padding1
   }
 
@@ -287,6 +295,7 @@ export class LendingMarket {
       minNetValueInObligationSf: dec.minNetValueInObligationSf,
       minValueSkipLiquidationLtvBfChecks:
         dec.minValueSkipLiquidationLtvBfChecks,
+      name: dec.name,
       padding1: dec.padding1,
     })
   }
@@ -320,6 +329,7 @@ export class LendingMarket {
       minNetValueInObligationSf: this.minNetValueInObligationSf.toString(),
       minValueSkipLiquidationLtvBfChecks:
         this.minValueSkipLiquidationLtvBfChecks.toString(),
+      name: this.name,
       padding1: this.padding1.map((item) => item.toString()),
     }
   }
@@ -358,6 +368,7 @@ export class LendingMarket {
       minValueSkipLiquidationLtvBfChecks: new BN(
         obj.minValueSkipLiquidationLtvBfChecks
       ),
+      name: obj.name,
       padding1: obj.padding1.map((item) => new BN(item)),
     })
   }