@kamino-finance/klend-sdk 5.1.0 → 5.1.1

package/src/classes/vault.ts

@@ -61,6 +61,7 @@ import bs58 from 'bs58';
 import { getProgramAccounts } from '../utils/rpc';
 
 export const kaminoVaultId = new PublicKey('kvauTFR8qm1dhniz6pYuBZkuene3Hfrs1VQhVRgCNrr');
+export const kaminoVaultStagingId = new PublicKey('STkvh7ostar39Fwr4uZKASs1RNNuYMFMTsE77FiRsL2');
 
 const TOKEN_VAULT_SEED = 'token_vault';
 const CTOKEN_VAULT_SEED = 'ctoken_vault';
@@ -391,7 +392,12 @@ export class KaminoVaultClient {
    * @param tokenAmount - token amount to be deposited, in decimals (will be converted in lamports)
    * @returns - an array of instructions to be used to be executed
    */
-  async depositIxs(user: PublicKey, vault: KaminoVault, tokenAmount: Decimal): Promise<TransactionInstruction[]> {
+  async depositIxs(
+    user: PublicKey,
+    vault: KaminoVault,
+    tokenAmount: Decimal,
+    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<TransactionInstruction[]> {
     const vaultState = await vault.getState(this._connection);
 
     const userTokenAta = getAssociatedTokenAddress(vaultState.tokenMint, user);
@@ -450,7 +456,7 @@ export class KaminoVaultClient {
 
     const vaultReserves = this.getVaultReserves(vaultState);
 
-    const vaultReservesState = await this.loadVaultReserves(vaultState);
+    const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
 
     let vaultReservesAccountMetas: AccountMeta[] = [];
     let vaultReservesLendingMarkets: AccountMeta[] = [];
@@ -983,13 +989,32 @@ export class KaminoVaultClient {
     return reserveAllocationAvailableLiquidityToWithdraw;
   }
 
-  private getVaultReserves(vault: VaultState): PublicKey[] {
+  /**
+   * This will get the list of all reserve pubkeys that the vault has allocations for
+   * @param vaultState - the vault state to load reserves for
+   * @returns a hashmap from each reserve pubkey to the reserve state
+   */
+  getAllVaultReserves(vault: VaultState): PublicKey[] {
+    return vault.vaultAllocationStrategy.map((vaultAllocation) => vaultAllocation.reserve);
+  }
+
+  /**
+   * This will get the list of all reserve pubkeys that the vault has allocations for ex
+   * @param vaultState - the vault state to load reserves for
+   * @returns a hashmap from each reserve pubkey to the reserve state
+   */
+  getVaultReserves(vault: VaultState): PublicKey[] {
     return vault.vaultAllocationStrategy
       .filter((vaultAllocation) => !vaultAllocation.reserve.equals(PublicKey.default))
       .map((vaultAllocation) => vaultAllocation.reserve);
   }
 
-  private async loadVaultReserves(vaultState: VaultState): Promise<PubkeyHashMap<PublicKey, KaminoReserve>> {
+  /**
+   * This will load the onchain state for all the reserves that the vault has allocations for
+   * @param vaultState - the vault state to load reserves for
+   * @returns a hashmap from each reserve pubkey to the reserve state
+   */
+  async loadVaultReserves(vaultState: VaultState): Promise<PubkeyHashMap<PublicKey, KaminoReserve>> {
     const vaultReservesAddresses = this.getVaultReserves(vaultState);
     const reserveAccounts = await this._connection.getMultipleAccountsInfo(vaultReservesAddresses, 'processed');
 
@@ -1026,6 +1051,122 @@ export class KaminoVaultClient {
 
     return kaminoReserves;
   }
+
+  /**
+   * This will return an Holdings object which contains the amount available (uninvested) in vault, total amount invested in reseves and a breakdown of the amount invested in each reserve
+   * @param vault - the kamino vault to get available liquidity to withdraw for
+   * @param slot - current slot
+   * @param vaultReserves - 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
+   * @returns an Holdings object
+   */
+  async getVaultHoldings(
+    vault: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<VaultHoldings> {
+    const vaultHoldings: VaultHoldings = {
+      available: new Decimal(vault.tokenAvailable.toString()),
+      invested: new Decimal(0),
+      investedInReserves: new PubkeyHashMap<PublicKey, Decimal>(),
+    };
+
+    const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
+
+    vault.vaultAllocationStrategy.forEach((allocationStrategy) => {
+      if (allocationStrategy.reserve.equals(PublicKey.default)) {
+        return;
+      }
+
+      const reserve = vaultReservesState.get(allocationStrategy.reserve);
+      if (reserve === undefined) {
+        throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
+      }
+
+      const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, 0);
+      const reserveAllocationLiquidityAmount = new Decimal(allocationStrategy.cTokenAllocation.toString()).mul(
+        reserveCollExchangeRate
+      );
+
+      vaultHoldings.invested = vaultHoldings.invested.add(reserveAllocationLiquidityAmount);
+      vaultHoldings.investedInReserves.set(allocationStrategy.reserve, reserveAllocationLiquidityAmount);
+    });
+
+    return vaultHoldings;
+  }
+
+  /**
+   * This will return an overview of each reserve that is part of the vault allocation
+   * @param vault - the kamino vault to get available liquidity to withdraw for
+   * @param slot - current slot
+   * @param vaultReserves - 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
+   * @returns a hashmap from vault reserve pubkey to ReserveOverview object
+   */
+  async getVaultReservesDetails(
+    vault: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<PubkeyHashMap<PublicKey, ReserveOverview>> {
+    const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
+    const reservesDetails = new PubkeyHashMap<PublicKey, ReserveOverview>();
+
+    vault.vaultAllocationStrategy.forEach((allocationStrategy) => {
+      if (allocationStrategy.reserve.equals(PublicKey.default)) {
+        return;
+      }
+
+      const reserve = vaultReservesState.get(allocationStrategy.reserve);
+      if (reserve === undefined) {
+        throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
+      }
+
+      reserve.getBorrowedAmount();
+      const reserveOverview: ReserveOverview = {
+        supplyAPY: new Decimal(reserve.totalSupplyAPY(slot)),
+        uUtilizationRatio: new Decimal(reserve.getEstimatedUtilizationRatio(slot, 0)),
+        liquidationThresholdPct: new Decimal(reserve.state.config.liquidationThresholdPct),
+        borrowedAmount: reserve.getBorrowedAmount(),
+      };
+      reservesDetails.set(allocationStrategy.reserve, reserveOverview);
+    });
+
+    return reservesDetails;
+  }
+
+  /**
+   * This will return the APY of the vault under the assumption that all the available tokens in the vault are all the time invested in the reserves
+   * @param vault - the kamino vault to get APY for
+   * @param slot - current slot
+   * @param vaultReserves - 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
+   * @returns APY for the vault
+   */
+  async getVaultTheoreticalAPY(
+    vault: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<Decimal> {
+    const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
+
+    let totalWeights = new Decimal(0);
+    let totalAPY = new Decimal(0);
+    vault.vaultAllocationStrategy.forEach((allocationStrategy) => {
+      if (allocationStrategy.reserve.equals(PublicKey.default)) {
+        return;
+      }
+
+      const reserve = vaultReservesState.get(allocationStrategy.reserve);
+      if (reserve === undefined) {
+        throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
+      }
+
+      const reserveAPY = new Decimal(reserve.totalSupplyAPY(slot));
+      const weight = new Decimal(allocationStrategy.targetAllocationWeight.toString());
+      const weightedAPY = reserveAPY.mul(weight);
+      totalAPY = totalAPY.add(weightedAPY);
+      totalWeights = totalWeights.add(weight);
+    });
+
+    return totalAPY.div(totalWeights);
+  }
 } // KaminoVaultClient
 
 export class KaminoVault {
@@ -1134,3 +1275,16 @@ export type VaultHolder = {
   holderPubkey: PublicKey;
   amount: Decimal;
 };
+
+export type VaultHoldings = {
+  available: Decimal;
+  invested: Decimal;
+  investedInReserves: PubkeyHashMap<PublicKey, Decimal>;
+};
+
+export type ReserveOverview = {
+  supplyAPY: Decimal;
+  uUtilizationRatio: Decimal;
+  liquidationThresholdPct: Decimal;
+  borrowedAmount: Decimal;
+};

package/src/client_kamino_manager.ts

@@ -496,6 +496,14 @@ async function main() {
     console.log('oracleConfigs', JSON.parse(JSON.stringify(oracleConfigs)));
   });
 
+  commands.command('get-all-vaults').action(async () => {
+    const env = initializeClient(false, false);
+    const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+    const allVaults = await kaminoManager.getAllVaults();
+    console.log('all vaults', allVaults);
+  });
+
   commands
     .command('download-lending-market-config')
     .requiredOption('--lending-market <string>', 'Lending Market Address')

package/src/idl_codegen_kamino_vault/accounts/VaultState.ts

@@ -1,179 +1,181 @@
-import { PublicKey, Connection } from "@solana/web3.js"
-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"
+import { PublicKey, Connection } from '@solana/web3.js';
+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 VaultStateFields {
-  adminAuthority: PublicKey
-  baseVaultAuthority: PublicKey
-  baseVaultAuthorityBump: BN
-  tokenMint: PublicKey
-  tokenMintDecimals: BN
-  tokenVault: PublicKey
-  tokenProgram: PublicKey
-  sharesMint: PublicKey
-  sharesMintDecimals: BN
-  tokenAvailable: BN
-  sharesIssued: BN
-  availableCrankFunds: BN
-  padding0: BN
-  performanceFeeBps: BN
-  managementFeeBps: BN
-  lastFeeChargeTimestamp: BN
-  prevAumSf: BN
-  pendingFeesSf: BN
-  vaultAllocationStrategy: Array<types.VaultAllocationFields>
-  minDepositAmount: BN
-  minWithdrawAmount: BN
-  minInvestAmount: BN
-  minInvestDelaySlots: BN
-  crankFundFeePerReserve: BN
-  pendingAdmin: PublicKey
-  padding1: BN
-  padding2: Array<BN>
+  adminAuthority: PublicKey;
+  baseVaultAuthority: PublicKey;
+  baseVaultAuthorityBump: BN;
+  tokenMint: PublicKey;
+  tokenMintDecimals: BN;
+  tokenVault: PublicKey;
+  tokenProgram: PublicKey;
+  sharesMint: PublicKey;
+  sharesMintDecimals: BN;
+  tokenAvailable: BN;
+  sharesIssued: BN;
+  availableCrankFunds: BN;
+  padding0: BN;
+  performanceFeeBps: BN;
+  managementFeeBps: BN;
+  lastFeeChargeTimestamp: BN;
+  prevAumSf: BN;
+  pendingFeesSf: BN;
+  vaultAllocationStrategy: Array<types.VaultAllocationFields>;
+  minDepositAmount: BN;
+  minWithdrawAmount: BN;
+  minInvestAmount: BN;
+  minInvestDelaySlots: BN;
+  crankFundFeePerReserve: BN;
+  pendingAdmin: PublicKey;
+  vaultLookupTable: PublicKey;
+  cumulativeNetEarnedYield: BN;
+  padding1: BN;
+  padding2: Array<BN>;
 }
 
 export interface VaultStateJSON {
-  adminAuthority: string
-  baseVaultAuthority: string
-  baseVaultAuthorityBump: string
-  tokenMint: string
-  tokenMintDecimals: string
-  tokenVault: string
-  tokenProgram: string
-  sharesMint: string
-  sharesMintDecimals: string
-  tokenAvailable: string
-  sharesIssued: string
-  availableCrankFunds: string
-  padding0: string
-  performanceFeeBps: string
-  managementFeeBps: string
-  lastFeeChargeTimestamp: string
-  prevAumSf: string
-  pendingFeesSf: string
-  vaultAllocationStrategy: Array<types.VaultAllocationJSON>
-  minDepositAmount: string
-  minWithdrawAmount: string
-  minInvestAmount: string
-  minInvestDelaySlots: string
-  crankFundFeePerReserve: string
-  pendingAdmin: string
-  padding1: string
-  padding2: Array<string>
+  adminAuthority: string;
+  baseVaultAuthority: string;
+  baseVaultAuthorityBump: string;
+  tokenMint: string;
+  tokenMintDecimals: string;
+  tokenVault: string;
+  tokenProgram: string;
+  sharesMint: string;
+  sharesMintDecimals: string;
+  tokenAvailable: string;
+  sharesIssued: string;
+  availableCrankFunds: string;
+  padding0: string;
+  performanceFeeBps: string;
+  managementFeeBps: string;
+  lastFeeChargeTimestamp: string;
+  prevAumSf: string;
+  pendingFeesSf: string;
+  vaultAllocationStrategy: Array<types.VaultAllocationJSON>;
+  minDepositAmount: string;
+  minWithdrawAmount: string;
+  minInvestAmount: string;
+  minInvestDelaySlots: string;
+  crankFundFeePerReserve: string;
+  pendingAdmin: string;
+  vaultLookupTable: string;
+  cumulativeNetEarnedYield: string;
+  padding1: string;
+  padding2: Array<string>;
 }
 
 export class VaultState {
-  readonly adminAuthority: PublicKey
-  readonly baseVaultAuthority: PublicKey
-  readonly baseVaultAuthorityBump: BN
-  readonly tokenMint: PublicKey
-  readonly tokenMintDecimals: BN
-  readonly tokenVault: PublicKey
-  readonly tokenProgram: PublicKey
-  readonly sharesMint: PublicKey
-  readonly sharesMintDecimals: BN
-  readonly tokenAvailable: BN
-  readonly sharesIssued: BN
-  readonly availableCrankFunds: BN
-  readonly padding0: BN
-  readonly performanceFeeBps: BN
-  readonly managementFeeBps: BN
-  readonly lastFeeChargeTimestamp: BN
-  readonly prevAumSf: BN
-  readonly pendingFeesSf: BN
-  readonly vaultAllocationStrategy: Array<types.VaultAllocation>
-  readonly minDepositAmount: BN
-  readonly minWithdrawAmount: BN
-  readonly minInvestAmount: BN
-  readonly minInvestDelaySlots: BN
-  readonly crankFundFeePerReserve: BN
-  readonly pendingAdmin: PublicKey
-  readonly padding1: BN
-  readonly padding2: Array<BN>
+  readonly adminAuthority: PublicKey;
+  readonly baseVaultAuthority: PublicKey;
+  readonly baseVaultAuthorityBump: BN;
+  readonly tokenMint: PublicKey;
+  readonly tokenMintDecimals: BN;
+  readonly tokenVault: PublicKey;
+  readonly tokenProgram: PublicKey;
+  readonly sharesMint: PublicKey;
+  readonly sharesMintDecimals: BN;
+  readonly tokenAvailable: BN;
+  readonly sharesIssued: BN;
+  readonly availableCrankFunds: BN;
+  readonly padding0: BN;
+  readonly performanceFeeBps: BN;
+  readonly managementFeeBps: BN;
+  readonly lastFeeChargeTimestamp: BN;
+  readonly prevAumSf: BN;
+  readonly pendingFeesSf: BN;
+  readonly vaultAllocationStrategy: Array<types.VaultAllocation>;
+  readonly minDepositAmount: BN;
+  readonly minWithdrawAmount: BN;
+  readonly minInvestAmount: BN;
+  readonly minInvestDelaySlots: BN;
+  readonly crankFundFeePerReserve: BN;
+  readonly pendingAdmin: PublicKey;
+  readonly vaultLookupTable: PublicKey;
+  readonly cumulativeNetEarnedYield: BN;
+  readonly padding1: BN;
+  readonly padding2: Array<BN>;
 
-  static readonly discriminator = Buffer.from([
-    228, 196, 82, 165, 98, 210, 235, 152,
-  ])
+  static readonly discriminator = Buffer.from([228, 196, 82, 165, 98, 210, 235, 152]);
 
   static readonly layout = borsh.struct([
-    borsh.publicKey("adminAuthority"),
-    borsh.publicKey("baseVaultAuthority"),
-    borsh.u64("baseVaultAuthorityBump"),
-    borsh.publicKey("tokenMint"),
-    borsh.u64("tokenMintDecimals"),
-    borsh.publicKey("tokenVault"),
-    borsh.publicKey("tokenProgram"),
-    borsh.publicKey("sharesMint"),
-    borsh.u64("sharesMintDecimals"),
-    borsh.u64("tokenAvailable"),
-    borsh.u64("sharesIssued"),
-    borsh.u64("availableCrankFunds"),
-    borsh.u64("padding0"),
-    borsh.u64("performanceFeeBps"),
-    borsh.u64("managementFeeBps"),
-    borsh.u64("lastFeeChargeTimestamp"),
-    borsh.u128("prevAumSf"),
-    borsh.u128("pendingFeesSf"),
-    borsh.array(types.VaultAllocation.layout(), 10, "vaultAllocationStrategy"),
-    borsh.u64("minDepositAmount"),
-    borsh.u64("minWithdrawAmount"),
-    borsh.u64("minInvestAmount"),
-    borsh.u64("minInvestDelaySlots"),
-    borsh.u64("crankFundFeePerReserve"),
-    borsh.publicKey("pendingAdmin"),
-    borsh.u64("padding1"),
-    borsh.array(borsh.u128(), 254, "padding2"),
-  ])
+    borsh.publicKey('adminAuthority'),
+    borsh.publicKey('baseVaultAuthority'),
+    borsh.u64('baseVaultAuthorityBump'),
+    borsh.publicKey('tokenMint'),
+    borsh.u64('tokenMintDecimals'),
+    borsh.publicKey('tokenVault'),
+    borsh.publicKey('tokenProgram'),
+    borsh.publicKey('sharesMint'),
+    borsh.u64('sharesMintDecimals'),
+    borsh.u64('tokenAvailable'),
+    borsh.u64('sharesIssued'),
+    borsh.u64('availableCrankFunds'),
+    borsh.u64('padding0'),
+    borsh.u64('performanceFeeBps'),
+    borsh.u64('managementFeeBps'),
+    borsh.u64('lastFeeChargeTimestamp'),
+    borsh.u128('prevAumSf'),
+    borsh.u128('pendingFeesSf'),
+    borsh.array(types.VaultAllocation.layout(), 10, 'vaultAllocationStrategy'),
+    borsh.u64('minDepositAmount'),
+    borsh.u64('minWithdrawAmount'),
+    borsh.u64('minInvestAmount'),
+    borsh.u64('minInvestDelaySlots'),
+    borsh.u64('crankFundFeePerReserve'),
+    borsh.publicKey('pendingAdmin'),
+    borsh.publicKey('vaultLookupTable'),
+    borsh.i128('cumulativeNetEarnedYield'),
+    borsh.u64('padding1'),
+    borsh.array(borsh.u128(), 251, 'padding2'),
+  ]);
 
   constructor(fields: VaultStateFields) {
-    this.adminAuthority = fields.adminAuthority
-    this.baseVaultAuthority = fields.baseVaultAuthority
-    this.baseVaultAuthorityBump = fields.baseVaultAuthorityBump
-    this.tokenMint = fields.tokenMint
-    this.tokenMintDecimals = fields.tokenMintDecimals
-    this.tokenVault = fields.tokenVault
-    this.tokenProgram = fields.tokenProgram
-    this.sharesMint = fields.sharesMint
-    this.sharesMintDecimals = fields.sharesMintDecimals
-    this.tokenAvailable = fields.tokenAvailable
-    this.sharesIssued = fields.sharesIssued
-    this.availableCrankFunds = fields.availableCrankFunds
-    this.padding0 = fields.padding0
-    this.performanceFeeBps = fields.performanceFeeBps
-    this.managementFeeBps = fields.managementFeeBps
-    this.lastFeeChargeTimestamp = fields.lastFeeChargeTimestamp
-    this.prevAumSf = fields.prevAumSf
-    this.pendingFeesSf = fields.pendingFeesSf
-    this.vaultAllocationStrategy = fields.vaultAllocationStrategy.map(
-      (item) => new types.VaultAllocation({ ...item })
-    )
-    this.minDepositAmount = fields.minDepositAmount
-    this.minWithdrawAmount = fields.minWithdrawAmount
-    this.minInvestAmount = fields.minInvestAmount
-    this.minInvestDelaySlots = fields.minInvestDelaySlots
-    this.crankFundFeePerReserve = fields.crankFundFeePerReserve
-    this.pendingAdmin = fields.pendingAdmin
-    this.padding1 = fields.padding1
-    this.padding2 = fields.padding2
+    this.adminAuthority = fields.adminAuthority;
+    this.baseVaultAuthority = fields.baseVaultAuthority;
+    this.baseVaultAuthorityBump = fields.baseVaultAuthorityBump;
+    this.tokenMint = fields.tokenMint;
+    this.tokenMintDecimals = fields.tokenMintDecimals;
+    this.tokenVault = fields.tokenVault;
+    this.tokenProgram = fields.tokenProgram;
+    this.sharesMint = fields.sharesMint;
+    this.sharesMintDecimals = fields.sharesMintDecimals;
+    this.tokenAvailable = fields.tokenAvailable;
+    this.sharesIssued = fields.sharesIssued;
+    this.availableCrankFunds = fields.availableCrankFunds;
+    this.padding0 = fields.padding0;
+    this.performanceFeeBps = fields.performanceFeeBps;
+    this.managementFeeBps = fields.managementFeeBps;
+    this.lastFeeChargeTimestamp = fields.lastFeeChargeTimestamp;
+    this.prevAumSf = fields.prevAumSf;
+    this.pendingFeesSf = fields.pendingFeesSf;
+    this.vaultAllocationStrategy = fields.vaultAllocationStrategy.map((item) => new types.VaultAllocation({ ...item }));
+    this.minDepositAmount = fields.minDepositAmount;
+    this.minWithdrawAmount = fields.minWithdrawAmount;
+    this.minInvestAmount = fields.minInvestAmount;
+    this.minInvestDelaySlots = fields.minInvestDelaySlots;
+    this.crankFundFeePerReserve = fields.crankFundFeePerReserve;
+    this.pendingAdmin = fields.pendingAdmin;
+    this.vaultLookupTable = fields.vaultLookupTable;
+    this.cumulativeNetEarnedYield = fields.cumulativeNetEarnedYield;
+    this.padding1 = fields.padding1;
+    this.padding2 = fields.padding2;
   }
 
-  static async fetch(
-    c: Connection,
-    address: PublicKey,
-    programId: PublicKey = PROGRAM_ID
-  ): Promise<VaultState | null> {
-    const info = await c.getAccountInfo(address)
+  static async fetch(c: Connection, address: PublicKey, programId: PublicKey = PROGRAM_ID): Promise<VaultState | null> {
+    const info = await c.getAccountInfo(address);
 
     if (info === null) {
-      return null
+      return null;
     }
     if (!info.owner.equals(programId)) {
-      throw new Error("account doesn't belong to this program")
+      throw new Error("account doesn't belong to this program");
     }
 
-    return this.decode(info.data)
+    return this.decode(info.data);
   }
 
   static async fetchMultiple(
@@ -181,26 +183,26 @@ export class VaultState {
     addresses: PublicKey[],
     programId: PublicKey = PROGRAM_ID
   ): Promise<Array<VaultState | null>> {
-    const infos = await c.getMultipleAccountsInfo(addresses)
+    const infos = await c.getMultipleAccountsInfo(addresses);
 
     return infos.map((info) => {
       if (info === null) {
-        return null
+        return null;
       }
       if (!info.owner.equals(programId)) {
-        throw new Error("account doesn't belong to this program")
+        throw new Error("account doesn't belong to this program");
       }
 
-      return this.decode(info.data)
-    })
+      return this.decode(info.data);
+    });
   }
 
   static decode(data: Buffer): VaultState {
-    if (!data.slice(0, 8).equals(VaultState.discriminator)) {
-      throw new Error("invalid account discriminator")
+    if (!VaultState.discriminator.equals(data.slice(0, 8))) {
+      throw new Error('invalid account discriminator');
     }
 
-    const dec = VaultState.layout.decode(data.slice(8))
+    const dec = VaultState.layout.decode(data.slice(8));
 
     return new VaultState({
       adminAuthority: dec.adminAuthority,
@@ -222,9 +224,8 @@ export class VaultState {
       prevAumSf: dec.prevAumSf,
       pendingFeesSf: dec.pendingFeesSf,
       vaultAllocationStrategy: dec.vaultAllocationStrategy.map(
-        (
-          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
-        ) => types.VaultAllocation.fromDecoded(item)
+        (item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */) =>
+          types.VaultAllocation.fromDecoded(item)
       ),
       minDepositAmount: dec.minDepositAmount,
       minWithdrawAmount: dec.minWithdrawAmount,
@@ -232,9 +233,11 @@ export class VaultState {
       minInvestDelaySlots: dec.minInvestDelaySlots,
       crankFundFeePerReserve: dec.crankFundFeePerReserve,
       pendingAdmin: dec.pendingAdmin,
+      vaultLookupTable: dec.vaultLookupTable,
+      cumulativeNetEarnedYield: dec.cumulativeNetEarnedYield,
       padding1: dec.padding1,
       padding2: dec.padding2,
-    })
+    });
   }
 
   toJSON(): VaultStateJSON {
@@ -257,18 +260,18 @@ export class VaultState {
       lastFeeChargeTimestamp: this.lastFeeChargeTimestamp.toString(),
       prevAumSf: this.prevAumSf.toString(),
       pendingFeesSf: this.pendingFeesSf.toString(),
-      vaultAllocationStrategy: this.vaultAllocationStrategy.map((item) =>
-        item.toJSON()
-      ),
+      vaultAllocationStrategy: this.vaultAllocationStrategy.map((item) => item.toJSON()),
       minDepositAmount: this.minDepositAmount.toString(),
       minWithdrawAmount: this.minWithdrawAmount.toString(),
       minInvestAmount: this.minInvestAmount.toString(),
       minInvestDelaySlots: this.minInvestDelaySlots.toString(),
       crankFundFeePerReserve: this.crankFundFeePerReserve.toString(),
       pendingAdmin: this.pendingAdmin.toString(),
+      vaultLookupTable: this.vaultLookupTable.toString(),
+      cumulativeNetEarnedYield: this.cumulativeNetEarnedYield.toString(),
       padding1: this.padding1.toString(),
       padding2: this.padding2.map((item) => item.toString()),
-    }
+    };
   }
 
   static fromJSON(obj: VaultStateJSON): VaultState {
@@ -291,17 +294,17 @@ export class VaultState {
       lastFeeChargeTimestamp: new BN(obj.lastFeeChargeTimestamp),
       prevAumSf: new BN(obj.prevAumSf),
       pendingFeesSf: new BN(obj.pendingFeesSf),
-      vaultAllocationStrategy: obj.vaultAllocationStrategy.map((item) =>
-        types.VaultAllocation.fromJSON(item)
-      ),
+      vaultAllocationStrategy: obj.vaultAllocationStrategy.map((item) => types.VaultAllocation.fromJSON(item)),
       minDepositAmount: new BN(obj.minDepositAmount),
       minWithdrawAmount: new BN(obj.minWithdrawAmount),
       minInvestAmount: new BN(obj.minInvestAmount),
       minInvestDelaySlots: new BN(obj.minInvestDelaySlots),
       crankFundFeePerReserve: new BN(obj.crankFundFeePerReserve),
       pendingAdmin: new PublicKey(obj.pendingAdmin),
+      vaultLookupTable: new PublicKey(obj.vaultLookupTable),
+      cumulativeNetEarnedYield: new BN(obj.cumulativeNetEarnedYield),
       padding1: new BN(obj.padding1),
       padding2: obj.padding2.map((item) => new BN(item)),
-    })
+    });
   }
 }