@kamino-finance/klend-sdk 5.4.0 → 5.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kamino-finance/klend-sdk",
-  "version": "5.4.0",
+  "version": "5.4.2",
   "description": "Typescript SDK for interacting with the Kamino Lending (klend) protocol",
   "repository": {
     "type": "git",
@@ -29,6 +29,7 @@
     "docs": "typedoc",
     "build": "rm -rf dist/; tsc",
     "build:test": "yarn tsc --project ./tests/tsconfig.json",
+    "build:watch": "yarn tsc --watch",
     "test": "npx ts-mocha tests/**/*.test.ts --exit",
     "watch": "tsc --watch",
     "coverage": "jest --coverage",
@@ -43,7 +44,9 @@
     "start-validator": "solana-test-validator $(./deps/test-validator-params.sh)",
     "start-validator-and-test": "yarn start-server-and-test 'yarn start-validator' http://127.0.0.1:8899/health test",
     "dump-programs": "./deps/dump-from-mainnet.sh",
-    "kamino-manager": "tsx src/client_kamino_manager.ts"
+    "kamino-manager": "tsx src/client_kamino_manager.ts",
+    "dev": "concurrently \"yarn build:watch\" \"nodemon --watch dist -e js,ts --exec 'yarn dev:push-and-update'\"",
+    "dev:push-and-update": "yalc publish && cd examples && yalc update"
   },
   "dependencies": {
     "@coral-xyz/anchor": "^0.28.0",
@@ -81,6 +84,7 @@
     "anchor-client-gen": "^0.28.1",
     "chai": "^4.3.7",
     "chai-bignumber": "^3.1.0",
+    "concurrently": "^9.1.0",
     "eslint": "^8.4.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-airbnb-typescript": "^16.1.0",
@@ -90,6 +94,7 @@
     "jest": "^27.4.3",
     "jest-fetch-mock": "^3.0.3",
     "mocha": "^10.2.0",
+    "nodemon": "^3.1.7",
     "prettier": "^2.8.8",
     "start-server-and-test": "^2.0.0",
     "ts-jest": "^28.0.7",

package/src/classes/action.ts

@@ -58,6 +58,7 @@ import {
   getAssociatedTokenAddress,
   ScopeRefresh,
   createAtasIdempotent,
+  POSITION_LIMIT,
 } from '../utils';
 import { KaminoMarket } from './market';
 import { KaminoObligation } from './obligation';
@@ -69,10 +70,6 @@ import { VanillaObligation } from '../utils/ObligationType';
 import { PROGRAM_ID } from '../lib';
 import { U16_MAX } from '@kamino-finance/scope-sdk';
 
-export const POSITION_LIMIT = 10;
-export const BORROWS_LIMIT = 5;
-export const DEPOSITS_LIMIT = 8;
-
 const SOL_PADDING_FOR_INTEREST = new BN('1000000');
 
 export type ActionType =

package/src/classes/manager.ts

@@ -17,6 +17,8 @@ import {
   MarketOverview,
   ReserveAllocationConfig,
   ReserveOverview,
+  SimulatedVaultHoldingsWithEarnedInterest,
+  VaultFees,
   VaultFeesPct,
   VaultHolder,
   VaultHoldings,
@@ -701,6 +703,32 @@ export class KaminoManager {
     return this._vaultClient.getVaultCumulativeInterest(vaultState);
   }
 
+  /**
+   * Simulate the current holdings of the vault and the earned interest
+   * @param vaultState the kamino vault state to get simulated holdings and earnings for
+   * @param vaultReserves optional; the state of the reserves in the vault allocation
+   * @returns a struct of simulated vault holdings and earned interest
+   */
+  async calculateSimulatedHoldingsWithInterest(
+    vaultState: VaultState,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<SimulatedVaultHoldingsWithEarnedInterest> {
+    return this._vaultClient.calculateSimulatedHoldingsWithInterest(vaultState, vaultReserves);
+  }
+
+  /**
+   * Simulate the current holdings and compute the fees that would be charged
+   * @param vaultState the kamino vault state to get simulated fees for
+   * @param simulatedCurrentHoldingsWithInterest optional; the simulated holdings and interest earned by the vault
+   * @returns a struct of simulated management and interest fees
+   */
+  async calculateSimulatedFees(
+    vaultState: VaultState,
+    simulatedCurrentHoldingsWithInterest?: SimulatedVaultHoldingsWithEarnedInterest
+  ): Promise<VaultFees> {
+    return this._vaultClient.calculateSimulatedFees(vaultState, simulatedCurrentHoldingsWithInterest);
+  }
+
   /**
    * 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

package/src/classes/market.ts

@@ -21,6 +21,7 @@ import {
   PubkeyHashMap,
   CandidatePrice,
   PublicKeySet,
+  DEPOSITS_LIMIT,
 } from '../utils';
 import base58 from 'bs58';
 import { BN } from '@coral-xyz/anchor';
@@ -727,6 +728,70 @@ export class KaminoMarket {
     });
   }
 
+  async getAllObligationsByDepositedReserve(reserve: PublicKey) {
+    const finalObligations: KaminoObligation[] = [];
+    for (let i = 0; i < DEPOSITS_LIMIT; i++) {
+      const [slot, obligations] = await Promise.all([
+        this.connection.getSlot(),
+        this.connection.getProgramAccounts(this.programId, {
+          filters: [
+            {
+              dataSize: Obligation.layout.span + 8,
+            },
+            {
+              memcmp: {
+                offset: 96 + 136 * i,
+                bytes: reserve.toBase58(),
+              },
+            },
+            {
+              memcmp: {
+                offset: 32,
+                bytes: this.address,
+              },
+            },
+          ],
+        }),
+      ]);
+
+      const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
+      const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
+
+      const obligationsBatch = obligations.map((obligation) => {
+        if (obligation.account === null) {
+          throw new Error('Invalid account');
+        }
+        if (!obligation.account.owner.equals(this.programId)) {
+          throw new Error("account doesn't belong to this program");
+        }
+
+        const obligationAccount = Obligation.decode(obligation.account.data);
+
+        if (!obligationAccount) {
+          throw Error('Could not parse obligation.');
+        }
+
+        KaminoObligation.addRatesForObligation(
+          this,
+          obligationAccount,
+          collateralExchangeRates,
+          cumulativeBorrowRates,
+          slot
+        );
+
+        return new KaminoObligation(
+          this,
+          obligation.pubkey,
+          obligationAccount,
+          collateralExchangeRates,
+          cumulativeBorrowRates
+        );
+      });
+      finalObligations.push(...obligationsBatch);
+    }
+    return finalObligations;
+  }
+
   async getAllUserObligations(user: PublicKey) {
     const [currentSlot, obligations] = await Promise.all([
       this.connection.getSlot(),

package/src/classes/vault.ts

@@ -58,7 +58,7 @@ import { withdraw } from '../idl_codegen_kamino_vault/instructions';
 import { PROGRAM_ID } from '../idl_codegen/programId';
 import { DEFAULT_RECENT_SLOT_DURATION_MS, ReserveWithAddress } from './reserve';
 import { Fraction } from './fraction';
-import { createAtasIdempotent, lendingMarketAuthPda, PublicKeySet } from '../utils';
+import { createAtasIdempotent, lendingMarketAuthPda, PublicKeySet, SECONDS_PER_YEAR } from '../utils';
 import bs58 from 'bs58';
 import { getAccountOwner, getProgramAccounts } from '../utils/rpc';
 import {
@@ -69,6 +69,7 @@ import {
   UpdateVaultConfigIxs,
 } from './types';
 import { collToLamportsDecimal } from '@kamino-finance/kliquidity-sdk';
+import { FullBPSDecimal } from '@kamino-finance/kliquidity-sdk/dist/utils/CreationParameters';
 
 export const kaminoVaultId = new PublicKey('kvauTFR8qm1dhniz6pYuBZkuene3Hfrs1VQhVRgCNrr');
 export const kaminoVaultStagingId = new PublicKey('STkvh7ostar39Fwr4uZKASs1RNNuYMFMTsE77FiRsL2');
@@ -675,8 +676,8 @@ export class KaminoVaultClient {
     const kaminoVault = new KaminoVault(vault.address, vaultState, vault.programId);
 
     // 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) {
@@ -734,18 +735,25 @@ export class KaminoVaultClient {
       },
     ]);
 
-    const tokensToWithdraw = shareAmount.mul(await this.getTokensPerShareSingleVault(vault, slot));
+    const shareLamportsToWithdraw = collToLamportsDecimal(shareAmount, vaultState.sharesMintDecimals.toNumber());
+    const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot);
+    const sharesPerToken = new Decimal(1).div(tokensPerShare);
+    const tokensToWithdraw = shareLamportsToWithdraw.mul(tokensPerShare);
     let tokenLeftToWithdraw = tokensToWithdraw;
+    const availableTokens = new Decimal(vaultState.tokenAvailable.toString());
+    tokenLeftToWithdraw = tokenLeftToWithdraw.sub(availableTokens);
 
-    tokenLeftToWithdraw = tokenLeftToWithdraw.sub(new Decimal(vaultState.tokenAvailable.toString()));
+    type ReserveWithTokensToWithdraw = { reserve: PublicKey; shares: Decimal };
 
-    const reservesToWithdraw: PublicKey[] = [];
-    const amountToWithdraw: Decimal[] = [];
-    amountToWithdraw.push(new Decimal(vaultState.tokenAvailable.toString()));
+    const reserveWithSharesAmountToWithdraw: ReserveWithTokensToWithdraw[] = [];
+    let isFirstWithdraw = true;
 
     if (tokenLeftToWithdraw.lte(0)) {
       // Availabe enough to withdraw all - using first reserve as it does not matter
-      reservesToWithdraw.push(vaultState.vaultAllocationStrategy[0].reserve);
+      reserveWithSharesAmountToWithdraw.push({
+        reserve: vaultState.vaultAllocationStrategy[0].reserve,
+        shares: shareLamportsToWithdraw,
+      });
     } else {
       // Get decreasing order sorted available liquidity to withdraw from each reserve allocated to
       const reserveAllocationAvailableLiquidityToWithdraw = await this.getReserveAllocationAvailableLiquidityToWithdraw(
@@ -754,15 +762,22 @@ export class KaminoVaultClient {
         vaultReservesState
       );
       // sort
-      const reserveAllocationAvailableLiquidityToWithdrawSorted = new PubkeyHashMap(
-        [...reserveAllocationAvailableLiquidityToWithdraw.entries()].sort((a, b) => b[1].sub(a[1]).toNumber())
-      );
+      const reserveAllocationAvailableLiquidityToWithdrawSorted = [
+        ...reserveAllocationAvailableLiquidityToWithdraw.entries(),
+      ].sort((a, b) => b[1].sub(a[1]).toNumber());
 
-      reserveAllocationAvailableLiquidityToWithdrawSorted.forEach((availableLiquidityToWithdraw, key) => {
+      reserveAllocationAvailableLiquidityToWithdrawSorted.forEach(([key, availableLiquidityToWithdraw], _) => {
         if (tokenLeftToWithdraw.gt(0)) {
-          reservesToWithdraw.push(key);
-          tokenLeftToWithdraw = tokenLeftToWithdraw.sub(availableLiquidityToWithdraw);
-          amountToWithdraw.push(Decimal.min(tokenLeftToWithdraw, availableLiquidityToWithdraw));
+          let tokensToWithdrawFromReserve = Decimal.min(tokenLeftToWithdraw, availableLiquidityToWithdraw);
+          if (isFirstWithdraw) {
+            tokensToWithdrawFromReserve = tokensToWithdrawFromReserve.add(availableTokens);
+            isFirstWithdraw = false;
+          }
+          // round up to the nearest integer the shares to withdraw
+          const sharesToWithdrawFromReserve = tokensToWithdrawFromReserve.mul(sharesPerToken).ceil();
+          reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: sharesToWithdrawFromReserve });
+
+          tokenLeftToWithdraw = tokenLeftToWithdraw.sub(tokensToWithdrawFromReserve);
         }
       });
     }
@@ -770,26 +785,35 @@ export class KaminoVaultClient {
     const withdrawIxns: TransactionInstruction[] = [];
     withdrawIxns.push(createAtaIx);
 
-    reservesToWithdraw.forEach((reserve, index) => {
-      const reserveState = vaultReservesState.get(reserve);
+    // let sharesLeftToWithdraw = shareAmount;
+    for (let reserveIndex = 0; reserveIndex < reserveWithSharesAmountToWithdraw.length; reserveIndex++) {
+      const reserveWithTokens = reserveWithSharesAmountToWithdraw[reserveIndex];
+      const reserveState = vaultReservesState.get(reserveWithTokens.reserve);
       if (reserveState === undefined) {
-        throw new Error(`Reserve ${reserve.toBase58()} not found in vault reserves map`);
+        throw new Error(`Reserve ${reserveWithTokens.reserve.toBase58()} not found in vault reserves map`);
       }
-
       const marketAddress = reserveState.state.lendingMarket;
+
+      const isLastWithdraw = reserveIndex === reserveWithSharesAmountToWithdraw.length - 1;
+      // if it is not last withdraw it means that we can pass all shares as we are withdrawing everything from that reserve
+      let sharesToWithdraw = shareAmount;
+      if (isLastWithdraw) {
+        sharesToWithdraw = reserveWithTokens.shares;
+      }
+      
       const withdrawFromReserveIx = this.withdrawIxn(
         user,
         vault,
         vaultState,
         marketAddress,
-        { address: reserve, state: reserveState.state },
+        { address: reserveWithTokens.reserve, state: reserveState.state },
         userSharesAta,
         userTokenAta,
-        amountToWithdraw[index],
+        sharesToWithdraw,
         vaultReservesState
       );
       withdrawIxns.push(withdrawFromReserveIx);
-    });
+    }
 
     return withdrawIxns;
   }
@@ -1483,18 +1507,23 @@ export class KaminoVaultClient {
 
     const reserveAllocationAvailableLiquidityToWithdraw = new PubkeyHashMap<PublicKey, Decimal>();
     vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
+      if (allocationStrategy.reserve.equals(PublicKey.default)) {
+        return;
+      }
       const reserve = reserves.get(allocationStrategy.reserve);
       if (reserve === undefined) {
         throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
       }
-      const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(
-        slot,
-        new Fraction(reserve.state.liquidity.absoluteReferralRateSf)
+      let referralFeeBps = 0;
+      const denominator = reserve.state.config.protocolTakeRatePct / 100;
+      if (denominator > 0) {
+        referralFeeBps = new Fraction(reserve.state.liquidity.absoluteReferralRateSf)
           .toDecimal()
-          .div(reserve.state.config.protocolTakeRatePct / 100)
+          .div(denominator)
           .floor()
-          .toNumber()
-      );
+          .toNumber();
+      }
+      const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, referralFeeBps);
       const reserveAllocationLiquidityAmount = new Decimal(allocationStrategy.ctokenAllocation.toString()).div(
         reserveCollExchangeRate
       );
@@ -1922,6 +1951,70 @@ export class KaminoVaultClient {
     const netYieldLamports = new Fraction(vaultState.cumulativeEarnedInterestSf).toDecimal();
     return lamportsToDecimal(netYieldLamports, vaultState.tokenMintDecimals.toString());
   }
+
+  /**
+   * Simulate the current holdings of the vault and the earned interest
+   * @param vaultState the kamino vault state to get simulated holdings and earnings for
+   * @param vaultReserves optional; the state of the reserves in the vault allocation
+   * @returns a struct of simulated vault holdings and earned interest
+   */
+  async calculateSimulatedHoldingsWithInterest(
+    vaultState: VaultState,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<SimulatedVaultHoldingsWithEarnedInterest> {
+    const latestUpdateTs = vaultState.lastFeeChargeTimestamp.toNumber();
+    const lastUpdateSlot = latestUpdateTs / this.recentSlotDurationMs;
+
+    const currentSlot = await this._connection.getSlot('confirmed');
+
+    const lastUpdateHoldingsPromise = this.getVaultHoldings(vaultState, lastUpdateSlot, vaultReserves);
+    const currentHoldingsPromise = this.getVaultHoldings(vaultState, currentSlot, vaultReserves);
+    const [lastUpdateHoldings, currentHoldings] = await Promise.all([
+      lastUpdateHoldingsPromise,
+      currentHoldingsPromise,
+    ]);
+
+    const earnedInterest = currentHoldings.total.sub(lastUpdateHoldings.total);
+
+    return {
+      holdings: currentHoldings,
+      earnedInterest: earnedInterest,
+    };
+  }
+
+  /**
+   * Simulate the current holdings and compute the fees that would be charged
+   * @param vaultState the kamino vault state to get simulated fees for
+   * @param simulatedCurrentHoldingsWithInterest optional; the simulated holdings and interest earned by the vault
+   * @returns a struct of simulated management and interest fees
+   */
+  async calculateSimulatedFees(
+    vaultState: VaultState,
+    simulatedCurrentHoldingsWithInterest?: SimulatedVaultHoldingsWithEarnedInterest
+  ): Promise<VaultFees> {
+    const timestampNow = new Date().getTime();
+    const timestampLastUpdate = vaultState.lastFeeChargeTimestamp.toNumber();
+    const timeElapsed = timestampNow - timestampLastUpdate;
+
+    const simulatedCurrentHoldings = simulatedCurrentHoldingsWithInterest
+      ? simulatedCurrentHoldingsWithInterest
+      : await this.calculateSimulatedHoldingsWithInterest(vaultState);
+
+    const performanceFee = simulatedCurrentHoldings.earnedInterest.mul(
+      new Decimal(vaultState.performanceFeeBps.toString()).div(FullBPSDecimal)
+    );
+
+    const managementFeeFactor = new Decimal(timeElapsed)
+      .mul(new Decimal(vaultState.managementFeeBps.toString()))
+      .div(new Decimal(SECONDS_PER_YEAR));
+    const prevAUM = new Fraction(vaultState.prevAumSf).toDecimal();
+    const mgmtFee = prevAUM.mul(managementFeeFactor);
+
+    return {
+      managementFee: mgmtFee,
+      performanceFee: performanceFee,
+    };
+  }
 } // KaminoVaultClient
 
 export class KaminoVault {
@@ -2042,6 +2135,11 @@ export type VaultHoldings = {
   total: Decimal;
 };
 
+export type SimulatedVaultHoldingsWithEarnedInterest = {
+  holdings: VaultHoldings;
+  earnedInterest: Decimal;
+};
+
 export type VaultHoldingsWithUSDValue = {
   holdings: VaultHoldings;
   availableUSD: Decimal;
@@ -2091,3 +2189,8 @@ export type VaultFeesPct = {
   managementFeePct: Decimal;
   performanceFeePct: Decimal;
 };
+
+export type VaultFees = {
+  managementFee: Decimal;
+  performanceFee: Decimal;
+};

package/src/client_kamino_manager.ts

@@ -649,7 +649,7 @@ async function main() {
       const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
       const instructions = await kaminoManager.depositToVaultIxs(env.payer.publicKey, kaminoVault, amount);
 
-      const depositSig = await processTxn(env.client, env.payer, instructions, mode, 2500, []);
+      const depositSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 800_000);
 
       mode === 'execute' && console.log('User deposit:', depositSig);
     });
@@ -675,14 +675,14 @@ async function main() {
       const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
       const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
-      const instructions = await kaminoManager.withdrawFromVaultIxs(
+      const withdrawIxs = await kaminoManager.withdrawFromVaultIxs(
         env.payer.publicKey,
         kaminoVault,
         new Decimal(amount),
         await env.connection.getSlot('confirmed')
       );
 
-      const depositSig = await processTxn(env.client, env.payer, instructions, mode, 2500, []);
+      const depositSig = await processTxn(env.client, env.payer, withdrawIxs, mode, 2500, [], 800_000);
 
       mode === 'execute' && console.log('User withdraw:', depositSig);
     });
@@ -754,7 +754,7 @@ async function main() {
         kaminoVault,
         reserveWithAddress
       );
-      const investReserveSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 800_000);
+      const investReserveSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 400_000);
 
       mode === 'execute' && console.log('Reserve invested:', investReserveSig);
     });
@@ -926,6 +926,37 @@ async function main() {
     console.log('all vaults', allVaults);
   });
 
+  commands.command('get-all-vaults-pks').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.map((vault) => vault.address.toBase58())
+    );
+  });
+
+  commands
+    .command('get-simulated-interest-and-fees')
+    .requiredOption('--vault <string>', 'Vault address')
+    .action(async ({ vault }) => {
+      const env = initializeClient(false, false);
+
+      const vaultAddress = new PublicKey(vault);
+
+      const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+      const vaultState = await new KaminoVault(vaultAddress, undefined, env.kVaultProgramId).getState(env.connection);
+
+      const simulatedHoldings = await kaminoManager.calculateSimulatedHoldingsWithInterest(vaultState);
+
+      console.log('Simulated holdings with interest', simulatedHoldings);
+
+      const simulatedFees = await kaminoManager.calculateSimulatedFees(vaultState, simulatedHoldings);
+
+      console.log('Simulated fees', simulatedFees);
+    });
+
   commands
     .command('download-lending-market-config')
     .requiredOption('--lending-market <string>', 'Lending Market Address')

package/src/idl_codegen_kamino_vault/accounts/VaultState.ts

@@ -36,6 +36,8 @@ export interface VaultStateFields {
   name: Array<number>
   vaultLookupTable: PublicKey
   vaultFarm: PublicKey
+  creationTimestamp: BN
+  padding1: BN
   padding2: Array<BN>
 }
 
@@ -71,6 +73,8 @@ export interface VaultStateJSON {
   name: Array<number>
   vaultLookupTable: string
   vaultFarm: string
+  creationTimestamp: string
+  padding1: string
   padding2: Array<string>
 }
 
@@ -106,6 +110,8 @@ export class VaultState {
   readonly name: Array<number>
   readonly vaultLookupTable: PublicKey
   readonly vaultFarm: PublicKey
+  readonly creationTimestamp: BN
+  readonly padding1: BN
   readonly padding2: Array<BN>
 
   static readonly discriminator = Buffer.from([
@@ -144,7 +150,9 @@ export class VaultState {
     borsh.array(borsh.u8(), 40, "name"),
     borsh.publicKey("vaultLookupTable"),
     borsh.publicKey("vaultFarm"),
-    borsh.array(borsh.u128(), 245, "padding2"),
+    borsh.u64("creationTimestamp"),
+    borsh.u64("padding1"),
+    borsh.array(borsh.u128(), 244, "padding2"),
   ])
 
   constructor(fields: VaultStateFields) {
@@ -181,6 +189,8 @@ export class VaultState {
     this.name = fields.name
     this.vaultLookupTable = fields.vaultLookupTable
     this.vaultFarm = fields.vaultFarm
+    this.creationTimestamp = fields.creationTimestamp
+    this.padding1 = fields.padding1
     this.padding2 = fields.padding2
   }
 
@@ -221,7 +231,7 @@ export class VaultState {
   }
 
   static decode(data: Buffer): VaultState {
-    if (!data.slice(0, 8).equals(VaultState.discriminator)) {
+    if (!VaultState.discriminator.equals(data.slice(0, 8))) {
       throw new Error("invalid account discriminator")
     }
 
@@ -263,6 +273,8 @@ export class VaultState {
       name: dec.name,
       vaultLookupTable: dec.vaultLookupTable,
       vaultFarm: dec.vaultFarm,
+      creationTimestamp: dec.creationTimestamp,
+      padding1: dec.padding1,
       padding2: dec.padding2,
     })
   }
@@ -302,6 +314,8 @@ export class VaultState {
       name: this.name,
       vaultLookupTable: this.vaultLookupTable.toString(),
       vaultFarm: this.vaultFarm.toString(),
+      creationTimestamp: this.creationTimestamp.toString(),
+      padding1: this.padding1.toString(),
       padding2: this.padding2.map((item) => item.toString()),
     }
   }
@@ -341,6 +355,8 @@ export class VaultState {
       name: obj.name,
       vaultLookupTable: new PublicKey(obj.vaultLookupTable),
       vaultFarm: new PublicKey(obj.vaultFarm),
+      creationTimestamp: new BN(obj.creationTimestamp),
+      padding1: new BN(obj.padding1),
       padding2: obj.padding2.map((item) => new BN(item)),
     })
   }

package/src/idl_codegen_kamino_vault/types/VaultAllocation.ts

@@ -9,6 +9,7 @@ export interface VaultAllocationFields {
   targetAllocationWeight: BN
   /** Maximum token invested in this reserve */
   tokenAllocationCap: BN
+  ctokenVaultBump: BN
   configPadding: Array<BN>
   ctokenAllocation: BN
   lastInvestSlot: BN
@@ -22,6 +23,7 @@ export interface VaultAllocationJSON {
   targetAllocationWeight: string
   /** Maximum token invested in this reserve */
   tokenAllocationCap: string
+  ctokenVaultBump: string
   configPadding: Array<string>
   ctokenAllocation: string
   lastInvestSlot: string
@@ -35,6 +37,7 @@ export class VaultAllocation {
   readonly targetAllocationWeight: BN
   /** Maximum token invested in this reserve */
   readonly tokenAllocationCap: BN
+  readonly ctokenVaultBump: BN
   readonly configPadding: Array<BN>
   readonly ctokenAllocation: BN
   readonly lastInvestSlot: BN
@@ -46,6 +49,7 @@ export class VaultAllocation {
     this.ctokenVault = fields.ctokenVault
     this.targetAllocationWeight = fields.targetAllocationWeight
     this.tokenAllocationCap = fields.tokenAllocationCap
+    this.ctokenVaultBump = fields.ctokenVaultBump
     this.configPadding = fields.configPadding
     this.ctokenAllocation = fields.ctokenAllocation
     this.lastInvestSlot = fields.lastInvestSlot
@@ -60,7 +64,8 @@ export class VaultAllocation {
         borsh.publicKey("ctokenVault"),
         borsh.u64("targetAllocationWeight"),
         borsh.u64("tokenAllocationCap"),
-        borsh.array(borsh.u64(), 128, "configPadding"),
+        borsh.u64("ctokenVaultBump"),
+        borsh.array(borsh.u64(), 127, "configPadding"),
         borsh.u64("ctokenAllocation"),
         borsh.u64("lastInvestSlot"),
         borsh.u128("tokenTargetAllocationSf"),
@@ -77,6 +82,7 @@ export class VaultAllocation {
       ctokenVault: obj.ctokenVault,
       targetAllocationWeight: obj.targetAllocationWeight,
       tokenAllocationCap: obj.tokenAllocationCap,
+      ctokenVaultBump: obj.ctokenVaultBump,
       configPadding: obj.configPadding,
       ctokenAllocation: obj.ctokenAllocation,
       lastInvestSlot: obj.lastInvestSlot,
@@ -91,6 +97,7 @@ export class VaultAllocation {
       ctokenVault: fields.ctokenVault,
       targetAllocationWeight: fields.targetAllocationWeight,
       tokenAllocationCap: fields.tokenAllocationCap,
+      ctokenVaultBump: fields.ctokenVaultBump,
       configPadding: fields.configPadding,
       ctokenAllocation: fields.ctokenAllocation,
       lastInvestSlot: fields.lastInvestSlot,
@@ -105,6 +112,7 @@ export class VaultAllocation {
       ctokenVault: this.ctokenVault.toString(),
       targetAllocationWeight: this.targetAllocationWeight.toString(),
       tokenAllocationCap: this.tokenAllocationCap.toString(),
+      ctokenVaultBump: this.ctokenVaultBump.toString(),
       configPadding: this.configPadding.map((item) => item.toString()),
       ctokenAllocation: this.ctokenAllocation.toString(),
       lastInvestSlot: this.lastInvestSlot.toString(),
@@ -119,6 +127,7 @@ export class VaultAllocation {
       ctokenVault: new PublicKey(obj.ctokenVault),
       targetAllocationWeight: new BN(obj.targetAllocationWeight),
       tokenAllocationCap: new BN(obj.tokenAllocationCap),
+      ctokenVaultBump: new BN(obj.ctokenVaultBump),
       configPadding: obj.configPadding.map((item) => new BN(item)),
       ctokenAllocation: new BN(obj.ctokenAllocation),
       lastInvestSlot: new BN(obj.lastInvestSlot),

package/src/utils/constants.ts

@@ -8,6 +8,8 @@ export const U64_MAX = '18446744073709551615';
 const INITIAL_COLLATERAL_RATIO = 1;
 export const INITIAL_COLLATERAL_RATE = new Decimal(INITIAL_COLLATERAL_RATIO);
 
+export const SECONDS_PER_YEAR = 365.242_199 * 24.0 * 60.0 * 60.0;
+
 export type ENV = 'mainnet-beta' | 'devnet' | 'localnet';
 
 export function isENV(value: any): value is ENV {
@@ -81,3 +83,7 @@ export const SOL_DECIMALS = 9;
 export const USDC_MAINNET_MINT = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
 
 export const MAINNET_BETA_CHAIN_ID = 101;
+
+export const POSITION_LIMIT = 10;
+export const BORROWS_LIMIT = 5;
+export const DEPOSITS_LIMIT = 8;