@kamino-finance/klend-sdk 5.11.6-beta.0 → 5.11.7

package/src/classes/index.ts

@@ -9,3 +9,4 @@ export * from './jupiterPerps';
 export * from './manager';
 export * from './vault';
 export * from './fraction';
+export * from './types';

package/src/classes/manager.ts

@@ -575,6 +575,32 @@ export class KaminoManager {
     return this._vaultClient.getAllVaults();
   }
 
+  /**
+   * Get all lending markets
+   * @returns an array of all lending markets
+   */
+  async getAllMarkets(): Promise<KaminoMarket[]> {
+    const lendingMarketsAccounts = await getProgramAccounts(
+      this.getConnection(),
+      this._kaminoLendProgramId,
+      LendingMarket.layout.span + 8,
+      {
+        commitment: this.getConnection().commitment ?? 'processed',
+        filters: [
+          { dataSize: LendingMarket.layout.span + 8 },
+          { memcmp: { offset: 0, bytes: bs58.encode(LendingMarket.discriminator) } },
+        ],
+      }
+    );
+
+    const markets = await Promise.all(
+      lendingMarketsAccounts.map((account) =>
+        KaminoMarket.load(this._connection, account.pubkey, this.recentSlotDurationMs, this._kaminoLendProgramId)
+      )
+    );
+    return markets.filter((market): market is KaminoMarket => market !== null);
+  }
+
   /**
    * Get all vaults for owner
    * @param owner the pubkey of the vaults owner
@@ -949,7 +975,7 @@ export class KaminoManager {
   }
 
   /**
-   * This retruns an array of scope oracle configs to be used to set the scope price and twap oracles for a reserve
+   * This returns an array of scope oracle configs to be used to set the scope price and twap oracles for a reserve
    * @param feed - scope feed to fetch prices from
    * @param cluster - cluster to fetch from, this should be left unchanged unless working on devnet or locally
    * @returns - an array of scope oracle configs

package/src/classes/market.ts

@@ -29,7 +29,7 @@ import Decimal from 'decimal.js';
 import { FarmState } from '@kamino-finance/farms-sdk';
 import { PROGRAM_ID } from '../idl_codegen/programId';
 import bs58 from 'bs58';
-import { OraclePrices, Scope } from '@kamino-finance/scope-sdk';
+import { OraclePrices, Scope, U16_MAX } from '@kamino-finance/scope-sdk';
 import { Fraction } from './fraction';
 import { chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
 import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
@@ -59,8 +59,6 @@ export class KaminoMarket {
 
   readonly programId: PublicKey;
 
-  scope: Scope;
-
   private readonly recentSlotDurationMs: number;
 
   private constructor(
@@ -68,7 +66,6 @@ export class KaminoMarket {
     state: LendingMarket,
     marketAddress: string,
     reserves: Map<PublicKey, KaminoReserve>,
-    scope: Scope,
     recentSlotDurationMs: number,
     programId: PublicKey = PROGRAM_ID
   ) {
@@ -78,7 +75,6 @@ export class KaminoMarket {
     this.reserves = reserves;
     this.reservesActive = getReservesActive(this.reserves);
     this.programId = programId;
-    this.scope = scope;
     this.recentSlotDurationMs = recentSlotDurationMs;
   }
 
@@ -97,7 +93,6 @@ export class KaminoMarket {
     marketAddress: PublicKey,
     recentSlotDurationMs: number,
     programId: PublicKey = PROGRAM_ID,
-    setupLocalTest: boolean = false,
     withReserves: boolean = true
   ) {
     const market = await LendingMarket.fetch(connection, marketAddress, programId);
@@ -105,26 +100,12 @@ export class KaminoMarket {
     if (market === null) {
       return null;
     }
-    let scope: Scope;
-    if (!setupLocalTest) {
-      scope = new Scope('mainnet-beta', connection);
-    } else {
-      scope = new Scope('localnet', connection);
-    }
 
     const reserves = withReserves
       ? await getReservesForMarket(marketAddress, connection, programId, recentSlotDurationMs)
       : new Map<PublicKey, KaminoReserve>();
 
-    return new KaminoMarket(
-      connection,
-      market,
-      marketAddress.toString(),
-      reserves,
-      scope,
-      recentSlotDurationMs,
-      programId
-    );
+    return new KaminoMarket(connection, market, marketAddress.toString(), reserves, recentSlotDurationMs, programId);
   }
 
   async reload(): Promise<void> {
@@ -1186,9 +1167,9 @@ export class KaminoMarket {
   /**
    * Get all Scope prices used by all the market reserves
    */
-  async getAllScopePrices(oraclePrices?: OraclePrices): Promise<KaminoPrices> {
+  async getAllScopePrices(scope: Scope, oraclePrices?: OraclePrices): Promise<KaminoPrices> {
     if (!oraclePrices) {
-      oraclePrices = await this.scope.getOraclePrices();
+      oraclePrices = await scope.getOraclePrices();
     }
     const spot: MintToPriceMap = {};
     const twaps: MintToPriceMap = {};
@@ -1199,11 +1180,11 @@ export class KaminoMarket {
       const chain = reserve.state.config.tokenInfo.scopeConfiguration.priceChain;
       const twapChain = reserve.state.config.tokenInfo.scopeConfiguration.twapChain.filter((x) => x > 0);
       if (oracle && isNotNullPubkey(oracle) && chain && Scope.isScopeChainValid(chain)) {
-        const spotPrice = await this.scope.getPriceFromChain(chain, oraclePrices);
+        const spotPrice = await scope.getPriceFromChain(chain, oraclePrices);
         spot[tokenMint] = { price: spotPrice.price, name: tokenName };
       }
       if (oracle && isNotNullPubkey(oracle) && twapChain && Scope.isScopeChainValid(twapChain)) {
-        const twap = await this.scope.getPriceFromChain(twapChain, oraclePrices);
+        const twap = await scope.getPriceFromChain(twapChain, oraclePrices);
         twaps[tokenMint] = { price: twap.price, name: tokenName };
       }
     }
@@ -1527,6 +1508,34 @@ export function getReservesActive(reserves: Map<PublicKey, KaminoReserve>): Map<
   return reservesActive;
 }
 
+export function getTokenIdsForScopeRefresh(kaminoMarket: KaminoMarket, reserves: PublicKey[]): number[] {
+  const tokenIds: number[] = [];
+
+  for (const reserveAddress of reserves) {
+    const reserve = kaminoMarket.getReserveByAddress(reserveAddress);
+    if (!reserve) {
+      throw new Error(`Reserve not found for reserve ${reserveAddress.toBase58()}`);
+    }
+
+    if (!reserve.state.config.tokenInfo.scopeConfiguration.priceFeed.equals(PublicKey.default)) {
+      let x = 0;
+
+      while (reserve.state.config.tokenInfo.scopeConfiguration.priceChain[x] !== U16_MAX) {
+        tokenIds.push(reserve.state.config.tokenInfo.scopeConfiguration.priceChain[x]);
+        x++;
+      }
+
+      x = 0;
+      while (reserve.state.config.tokenInfo.scopeConfiguration.twapChain[x] !== U16_MAX) {
+        tokenIds.push(reserve.state.config.tokenInfo.scopeConfiguration.twapChain[x]);
+        x++;
+      }
+    }
+  }
+
+  return tokenIds;
+}
+
 export async function getReserveFromMintAndMarket(
   connection: Connection,
   market: KaminoMarket,

package/src/classes/obligation.ts

@@ -17,6 +17,7 @@ import {
   getObligationPdaWithArgs,
   getObligationType,
   isNotNullPubkey,
+  ObligationType,
   PubkeyHashMap,
   TOTAL_NUMBER_OF_IDS_TO_CHECK,
   U64_MAX,
@@ -1593,3 +1594,8 @@ export class KaminoObligation {
     }
   }
 }
+
+// Create a function that checks if an obligation is of type obligation or obligationType
+export function isKaminoObligation(obligation: KaminoObligation | ObligationType): obligation is KaminoObligation {
+  return 'obligationAddress' in obligation;
+}

package/src/classes/types.ts

@@ -58,4 +58,4 @@ export type ReserveAllocationOverview = {
 export type APYs = {
   grossAPY: Decimal;
   netAPY: Decimal;
-}
+};

package/src/classes/vault.ts

@@ -11,7 +11,7 @@ import {
   SYSVAR_RENT_PUBKEY,
   TransactionInstruction,
 } from '@solana/web3.js';
-import { NATIVE_MINT, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
+import { getAssociatedTokenAddressSync, NATIVE_MINT, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
 import {
   getAssociatedTokenAddress,
   getTransferWsolIxns,
@@ -100,6 +100,8 @@ const CTOKEN_VAULT_SEED = 'ctoken_vault';
 const BASE_VAULT_AUTHORITY_SEED = 'authority';
 const SHARES_SEED = 'shares';
 
+export const INITIAL_DEPOSIT_LAMPORTS = 1000;
+
 /**
  * KaminoVaultClient is a class that provides a high-level interface to interact with the Kamino Vault program.
  */
@@ -195,6 +197,8 @@ export class KaminoVaultClient {
       this._kaminoVaultProgramId
     )[0];
 
+    const adminTokenAccount = getAssociatedTokenAddressSync(vaultConfig.tokenMint, vaultConfig.admin, false);
+
     const initVaultAccounts: InitVaultAccounts = {
       adminAuthority: vaultConfig.admin,
       vaultState: vaultState.publicKey,
@@ -206,6 +210,7 @@ export class KaminoVaultClient {
       rent: SYSVAR_RENT_PUBKEY,
       tokenProgram: vaultConfig.tokenMintProgramId,
       sharesTokenProgram: TOKEN_PROGRAM_ID,
+      adminTokenAccount,
     };
     const initVaultIx = initVault(initVaultAccounts, this._kaminoVaultProgramId);
 
@@ -288,7 +293,7 @@ export class KaminoVaultClient {
     );
 
     const updateReserveAllocationAccounts: UpdateReserveAllocationAccounts = {
-      adminAuthority: vaultState.adminAuthority,
+      signer: vaultState.vaultAdminAuthority,
       vaultState: vault.address,
       baseVaultAuthority: vaultState.baseVaultAuthority,
       reserveCollateralMint: reserveState.collateral.mintPubkey,
@@ -296,7 +301,7 @@ export class KaminoVaultClient {
       ctokenVault: cTokenVault,
       systemProgram: SystemProgram.programId,
       rent: SYSVAR_RENT_PUBKEY,
-      reserveCollateralTokenProgram: vaultState.tokenProgram,
+      reserveCollateralTokenProgram: TOKEN_PROGRAM_ID,
     };
 
     const updateReserveAllocationArgs: UpdateReserveAllocationArgs = {
@@ -320,7 +325,7 @@ export class KaminoVaultClient {
     accountsToAddToLUT.push(lendingMarketAuth);
 
     const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(
-      vaultState.adminAuthority,
+      vaultState.vaultAdminAuthority,
       vaultState.vaultLookupTable,
       accountsToAddToLUT
     );
@@ -350,12 +355,12 @@ export class KaminoVaultClient {
     const vaultState: VaultState = await vault.getState(this.getConnection());
 
     const updateVaultConfigAccs: UpdateVaultConfigAccounts = {
-      adminAuthority: vaultState.adminAuthority,
+      vaultAdminAuthority: vaultState.vaultAdminAuthority,
       vaultState: vault.address,
       klendProgram: this._kaminoLendProgramId,
     };
     if (signer) {
-      updateVaultConfigAccs.adminAuthority = signer;
+      updateVaultConfigAccs.vaultAdminAuthority = signer;
     }
 
     const updateVaultConfigArgs: UpdateVaultConfigArgs = {
@@ -409,7 +414,7 @@ export class KaminoVaultClient {
     if (mode.kind === new VaultConfigField.PendingVaultAdmin().kind) {
       const newPubkey = new PublicKey(value);
       const insertIntoLutIxs = await this.insertIntoLookupTableIxs(
-        vaultState.adminAuthority,
+        vaultState.vaultAdminAuthority,
         vaultState.vaultLookupTable,
         [newPubkey]
       );
@@ -427,7 +432,7 @@ export class KaminoVaultClient {
           farmState!.globalConfig
         );
         const insertIntoLutIxs = await this.insertIntoLookupTableIxs(
-          vaultState.adminAuthority,
+          vaultState.vaultAdminAuthority,
           vaultState.vaultLookupTable,
           keysToAddToLUT
         );
@@ -476,7 +481,7 @@ export class KaminoVaultClient {
     value: string
   ): TransactionInstruction {
     const updateVaultConfigAccs: UpdateVaultConfigAccounts = {
-      adminAuthority: admin,
+      vaultAdminAuthority: admin,
       vaultState: vault,
       klendProgram: this._kaminoLendProgramId,
     };
@@ -526,7 +531,7 @@ export class KaminoVaultClient {
 
     // read the current LUT and create a new one for the new admin and backfill it
     const accountsInExistentLUT = (await getAccountsInLUT(this.getConnection(), vaultState.vaultLookupTable)).filter(
-      (account) => !account.equals(vaultState.adminAuthority)
+      (account) => !account.equals(vaultState.vaultAdminAuthority)
     );
 
     const LUTIxs: TransactionInstruction[] = [];
@@ -569,7 +574,7 @@ export class KaminoVaultClient {
     const vaultState: VaultState = await vault.getState(this.getConnection());
 
     const giveUpPendingFeesAccounts: GiveUpPendingFeesAccounts = {
-      adminAuthority: vaultState.adminAuthority,
+      vaultAdminAuthority: vaultState.vaultAdminAuthority,
       vaultState: vault.address,
       klendProgram: this._kaminoLendProgramId,
     };
@@ -599,7 +604,7 @@ export class KaminoVaultClient {
   ): Promise<TransactionInstruction[]> {
     const vaultState: VaultState = await vault.getState(this.getConnection());
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
-    const [{ ata: adminTokenAta, createAtaIx }] = createAtasIdempotent(vaultState.adminAuthority, [
+    const [{ ata: adminTokenAta, createAtaIx }] = createAtasIdempotent(vaultState.vaultAdminAuthority, [
       {
         mint: vaultState.tokenMint,
         tokenProgram: TOKEN_PROGRAM_ID,
@@ -1010,20 +1015,16 @@ export class KaminoVaultClient {
     if (allReserves.length === 0) {
       throw new Error('No reserves found for the vault, please select at least one reserve for the vault');
     }
-
     const [allReservesStateMap, computedReservesAllocation] = await Promise.all([
       this.loadVaultReserves(vaultState),
       this.getVaultComputedReservesAllocation(vaultState),
     ]);
-
     const tokenProgram = await getAccountOwner(this.getConnection(), vaultState.tokenMint);
     const [{ ata: _payerTokenAta, createAtaIx }] = createAtasIdempotent(payer, [
       { mint: vaultState.tokenMint, tokenProgram },
     ]);
-
     // compute total vault holdings and expected distribution based on weights
     const curentVaultAllocations = this.getVaultAllocations(vaultState);
-
     const reservesToDisinvestFrom: PublicKey[] = [];
     const reservesToInvestInto: PublicKey[] = [];
 
@@ -1294,7 +1295,7 @@ export class KaminoVaultClient {
     const lendingMarketAuth = lendingMarketAuthPda(marketAddress, this._kaminoLendProgramId)[0];
 
     const withdrawPendingFeesAccounts: WithdrawPendingFeesAccounts = {
-      adminAuthority: vaultState.adminAuthority,
+      vaultAdminAuthority: vaultState.vaultAdminAuthority,
       vaultState: vault.address,
       reserve: reserve.address,
       tokenVault: vaultState.tokenVault,
@@ -1354,7 +1355,7 @@ export class KaminoVaultClient {
     const vaultState = await vault.getState(this.getConnection());
     const allAccountsToBeInserted = [
       vault.address,
-      vaultState.adminAuthority,
+      vaultState.vaultAdminAuthority,
       vaultState.baseVaultAuthority,
       vaultState.tokenMint,
       vaultState.tokenVault,
@@ -1399,7 +1400,7 @@ export class KaminoVaultClient {
     let lut = vaultState.vaultLookupTable;
     if (lut.equals(PublicKey.default)) {
       const recentSlot = await this.getConnection().getSlot();
-      const [ixn, address] = initLookupTableIx(vaultState.adminAuthority, recentSlot);
+      const [ixn, address] = initLookupTableIx(vaultState.vaultAdminAuthority, recentSlot);
       setupLUTIfNeededIxs.push(ixn);
       lut = address;
 
@@ -1419,7 +1420,7 @@ export class KaminoVaultClient {
     }
     ixns.push(
       ...(await this.insertIntoLookupTableIxs(
-        vaultState.adminAuthority,
+        vaultState.vaultAdminAuthority,
         lut,
         allAccountsToBeInserted,
         overridenExistentAccounts
@@ -1528,16 +1529,19 @@ export class KaminoVaultClient {
 
     let totalLeftToInvest = holdings.totalAUMIncludingFees.sub(holdings.pendingFees);
     let currentAllocationSum = totalAllocation;
-    const ZERO = new Decimal(0);
-    while (totalLeftToInvest.gt(ZERO)) {
+    const ONE = new Decimal(1);
+    while (totalLeftToInvest.gt(ONE)) {
       const totalLeftover = totalLeftToInvest;
       for (const reserve of allReserves) {
         const reserveWithWeight = initialVaultAllocations.get(reserve);
         const targetAllocation = reserveWithWeight!.targetWeight.mul(totalLeftover).div(currentAllocationSum);
         const reserveCap = reserveWithWeight!.tokenAllocationCap;
-        const amountToInvest = Decimal.min(targetAllocation, reserveCap, totalLeftToInvest);
+        let amountToInvest = Decimal.min(targetAllocation, totalLeftToInvest);
+        if (reserveCap.gt(ZERO)) {
+          amountToInvest = Decimal.min(amountToInvest, reserveCap);
+        }
         totalLeftToInvest = totalLeftToInvest.sub(amountToInvest);
-        if (amountToInvest.eq(reserveCap)) {
+        if (amountToInvest.eq(reserveCap) && reserveCap.gt(ZERO)) {
           currentAllocationSum = currentAllocationSum.sub(reserveWithWeight!.targetWeight);
         }
         const reserveHasPreallocation = expectedHoldingsDistribution.has(reserve);

package/src/client.ts

@@ -22,6 +22,7 @@ import { VanillaObligation } from './utils/ObligationType';
 import { parseTokenSymbol } from './classes/utils';
 import { Env, initEnv } from '../tests/runner/setup_utils';
 import { initializeFarmsForReserve } from '../tests/runner/farms/farms_operations';
+import { Scope } from '@kamino-finance/scope-sdk';
 
 const STAGING_LENDING_MARKET = new PublicKey('6WVSwDQXrBZeQVnu6hpnsRZhodaJTZBUaC334SiiBKdb');
 const MAINNET_LENDING_MARKET = new PublicKey('7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF');
@@ -61,9 +62,17 @@ async function main() {
     .option(`--rpc <string>`, 'The RPC URL')
     .action(async ({ rpc }) => {
       const connection = new Connection(rpc, {});
-      for await (const lendingMarketAccount of getAllLendingMarketAccounts(connection)) {
-        console.log(toJson(lendingMarketAccount.toJSON()));
+      let count = 0;
+      for await (const [address, lendingMarketAccount] of getAllLendingMarketAccounts(connection)) {
+        count++;
+        console.log(
+          address.toString(),
+          lendingMarketAccount.riskCouncil.toString(),
+          lendingMarketAccount.autodeleverageEnabled,
+          lendingMarketAccount.individualAutodeleverageMarginCallPeriodSecs.toString()
+        );
       }
+      console.log(`Total lending markets: ${count}`);
     });
 
   commands
@@ -83,9 +92,17 @@ async function main() {
     .option(`--rpc <string>`, 'The RPC URL')
     .action(async ({ rpc }) => {
       const connection = new Connection(rpc, {});
-      for await (const obligationAccount of getAllObligationAccounts(connection)) {
-        console.log(toJson(obligationAccount.toJSON()));
+      let count = 0;
+      for await (const [address, obligationAccount] of getAllObligationAccounts(connection)) {
+        count++;
+        if (
+          obligationAccount.autodeleverageTargetLtvPct > 0 ||
+          obligationAccount.autodeleverageMarginCallStartedTimestamp.toNumber() > 0
+        ) {
+          console.log(address.toString(), toJson(obligationAccount.toJSON()));
+        }
       }
+      console.log(`Total obligations: ${count}`);
     });
 
   commands
@@ -103,9 +120,19 @@ async function main() {
     .option(`--rpc <string>`, 'The RPC URL')
     .action(async ({ rpc }) => {
       const connection = new Connection(rpc, {});
-      for await (const reserveAccount of getAllReserveAccounts(connection)) {
-        console.log(toJson(reserveAccount.toJSON()));
+      let count = 0;
+      const logItems: { address: string; value: string; index: number }[] = [];
+      for await (const [address, reserveAccount] of getAllReserveAccounts(connection)) {
+        count++;
+        const logItem = {
+          address: address.toString(),
+          value: reserveAccount.config.autodeleverageEnabled.toString(),
+          index: count,
+        };
+        logItems.push(logItem);
       }
+      console.log(`Total reserves: ${count}`);
+      console.log(logItems);
     });
 
   commands
@@ -309,7 +336,8 @@ async function deposit(connection: Connection, wallet: Keypair, token: string, d
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
     new VanillaObligation(STAGING_LENDING_MARKET),
-    true
+    true,
+    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -330,7 +358,8 @@ async function withdraw(connection: Connection, wallet: Keypair, token: string,
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
-    true
+    true,
+    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -351,7 +380,8 @@ async function borrow(connection: Connection, wallet: Keypair, token: string, bo
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
-    true
+    true,
+    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -373,6 +403,7 @@ async function repay(connection: Connection, wallet: Keypair, token: string, bor
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
     true,
+    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' },
     await connection.getSlot()
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());

package/src/client_kamino_manager.ts

@@ -1019,6 +1019,21 @@ async function main() {
       );
     });
 
+  commands
+    .command('compute-alloc')
+    .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 computedAllocation = await kaminoManager.getVaultComputedReservesAllocation(vaultState);
+      console.log('computedAllocation', computedAllocation);
+    });
+
   commands
     .command('download-lending-market-config-and-all-reserves-configs')
     .requiredOption('--lending-market <string>', 'Lending Market Address')

package/src/idl_codegen_kamino_vault/accounts/VaultState.ts

@@ -5,7 +5,7 @@ import * as types from "../types" // eslint-disable-line @typescript-eslint/no-u
 import { PROGRAM_ID } from "../programId"
 
 export interface VaultStateFields {
-  adminAuthority: PublicKey
+  vaultAdminAuthority: PublicKey
   baseVaultAuthority: PublicKey
   baseVaultAuthorityBump: BN
   tokenMint: PublicKey
@@ -38,11 +38,12 @@ export interface VaultStateFields {
   vaultFarm: PublicKey
   creationTimestamp: BN
   padding1: BN
+  allocationAdmin: PublicKey
   padding2: Array<BN>
 }
 
 export interface VaultStateJSON {
-  adminAuthority: string
+  vaultAdminAuthority: string
   baseVaultAuthority: string
   baseVaultAuthorityBump: string
   tokenMint: string
@@ -75,11 +76,12 @@ export interface VaultStateJSON {
   vaultFarm: string
   creationTimestamp: string
   padding1: string
+  allocationAdmin: string
   padding2: Array<string>
 }
 
 export class VaultState {
-  readonly adminAuthority: PublicKey
+  readonly vaultAdminAuthority: PublicKey
   readonly baseVaultAuthority: PublicKey
   readonly baseVaultAuthorityBump: BN
   readonly tokenMint: PublicKey
@@ -112,6 +114,7 @@ export class VaultState {
   readonly vaultFarm: PublicKey
   readonly creationTimestamp: BN
   readonly padding1: BN
+  readonly allocationAdmin: PublicKey
   readonly padding2: Array<BN>
 
   static readonly discriminator = Buffer.from([
@@ -119,7 +122,7 @@ export class VaultState {
   ])
 
   static readonly layout = borsh.struct([
-    borsh.publicKey("adminAuthority"),
+    borsh.publicKey("vaultAdminAuthority"),
     borsh.publicKey("baseVaultAuthority"),
     borsh.u64("baseVaultAuthorityBump"),
     borsh.publicKey("tokenMint"),
@@ -152,11 +155,12 @@ export class VaultState {
     borsh.publicKey("vaultFarm"),
     borsh.u64("creationTimestamp"),
     borsh.u64("padding1"),
-    borsh.array(borsh.u128(), 244, "padding2"),
+    borsh.publicKey("allocationAdmin"),
+    borsh.array(borsh.u128(), 242, "padding2"),
   ])
 
   constructor(fields: VaultStateFields) {
-    this.adminAuthority = fields.adminAuthority
+    this.vaultAdminAuthority = fields.vaultAdminAuthority
     this.baseVaultAuthority = fields.baseVaultAuthority
     this.baseVaultAuthorityBump = fields.baseVaultAuthorityBump
     this.tokenMint = fields.tokenMint
@@ -191,6 +195,7 @@ export class VaultState {
     this.vaultFarm = fields.vaultFarm
     this.creationTimestamp = fields.creationTimestamp
     this.padding1 = fields.padding1
+    this.allocationAdmin = fields.allocationAdmin
     this.padding2 = fields.padding2
   }
 
@@ -238,7 +243,7 @@ export class VaultState {
     const dec = VaultState.layout.decode(data.slice(8))
 
     return new VaultState({
-      adminAuthority: dec.adminAuthority,
+      vaultAdminAuthority: dec.vaultAdminAuthority,
       baseVaultAuthority: dec.baseVaultAuthority,
       baseVaultAuthorityBump: dec.baseVaultAuthorityBump,
       tokenMint: dec.tokenMint,
@@ -275,13 +280,14 @@ export class VaultState {
       vaultFarm: dec.vaultFarm,
       creationTimestamp: dec.creationTimestamp,
       padding1: dec.padding1,
+      allocationAdmin: dec.allocationAdmin,
       padding2: dec.padding2,
     })
   }
 
   toJSON(): VaultStateJSON {
     return {
-      adminAuthority: this.adminAuthority.toString(),
+      vaultAdminAuthority: this.vaultAdminAuthority.toString(),
       baseVaultAuthority: this.baseVaultAuthority.toString(),
       baseVaultAuthorityBump: this.baseVaultAuthorityBump.toString(),
       tokenMint: this.tokenMint.toString(),
@@ -316,13 +322,14 @@ export class VaultState {
       vaultFarm: this.vaultFarm.toString(),
       creationTimestamp: this.creationTimestamp.toString(),
       padding1: this.padding1.toString(),
+      allocationAdmin: this.allocationAdmin.toString(),
       padding2: this.padding2.map((item) => item.toString()),
     }
   }
 
   static fromJSON(obj: VaultStateJSON): VaultState {
     return new VaultState({
-      adminAuthority: new PublicKey(obj.adminAuthority),
+      vaultAdminAuthority: new PublicKey(obj.vaultAdminAuthority),
       baseVaultAuthority: new PublicKey(obj.baseVaultAuthority),
       baseVaultAuthorityBump: new BN(obj.baseVaultAuthorityBump),
       tokenMint: new PublicKey(obj.tokenMint),
@@ -357,6 +364,7 @@ export class VaultState {
       vaultFarm: new PublicKey(obj.vaultFarm),
       creationTimestamp: new BN(obj.creationTimestamp),
       padding1: new BN(obj.padding1),
+      allocationAdmin: new PublicKey(obj.allocationAdmin),
       padding2: obj.padding2.map((item) => new BN(item)),
     })
   }