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

package/src/classes/index.ts

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

package/src/classes/lut_utils.ts

@@ -0,0 +1,63 @@
+import { AddressLookupTableProgram, Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
+
+/**
+ * This method retuns an instruction that creates a lookup table, alongside the pubkey of the lookup table
+ * @param payer - the owner of the lookup table
+ * @param slot - the current slot
+ * @returns - the instruction to create the lookup table and its address
+ */
+export function initLookupTableIx(payer: PublicKey, slot: number): [TransactionInstruction, PublicKey] {
+  const [ixn, address] = AddressLookupTableProgram.createLookupTable({
+    authority: payer,
+    payer,
+    recentSlot: slot,
+  });
+
+  return [ixn, address];
+}
+
+/**
+ * This method retuns an instruction that deactivates a lookup table, which is needed to close it
+ * @param payer - the owner of the lookup table
+ * @param lookupTable - the lookup table to deactivate
+ * @returns - the instruction to deactivate the lookup table
+ */
+export function deactivateLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction {
+  const ixn = AddressLookupTableProgram.deactivateLookupTable({
+    authority: payer,
+    lookupTable: lookupTable,
+  });
+
+  return ixn;
+}
+
+/**
+ * This method returns an instruction that closes a lookup table. That lookup table needs to be disabled at least 500 blocks before closing it.
+ * @param payer - the owner of the lookup table
+ * @param lookupTable - the lookup table to close
+ * @returns - the instruction to close the lookup table
+ */
+/// this require the LUT to be deactivated at least 500 blocks before
+export function closeLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction {
+  const ixn = AddressLookupTableProgram.closeLookupTable({
+    authority: payer,
+    recipient: payer,
+    lookupTable: lookupTable,
+  });
+
+  return ixn;
+}
+
+/**
+ * Returns the accounts in a lookup table
+ * @param lookupTable - lookup table to get the accounts from
+ * @returns - an array of accounts in the lookup table
+ */
+export async function getAccountsInLUT(connection: Connection, lookupTable: PublicKey): Promise<PublicKey[]> {
+  const lutState = await connection.getAddressLookupTable(lookupTable);
+  if (!lutState || !lutState.value) {
+    throw new Error(`Lookup table ${lookupTable} not found`);
+  }
+
+  return lutState.value.state.addresses;
+}

package/src/classes/manager.ts

@@ -50,7 +50,6 @@ import {
   ReserveWithAddress,
   sameLengthArrayEquals,
   ScopeOracleConfig,
-  sleep,
   updateEntireReserveConfigIx,
   updateLendingMarket,
   UpdateLendingMarketAccounts,
@@ -576,34 +575,6 @@ 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) } },
-        ],
-      }
-    );
-
-    await sleep(500);
-
-    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
@@ -978,7 +949,7 @@ export class KaminoManager {
   }
 
   /**
-   * This returns an array of scope oracle configs to be used to set the scope price and twap oracles for a reserve
+   * This retruns 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, U16_MAX } from '@kamino-finance/scope-sdk';
+import { OraclePrices, Scope } from '@kamino-finance/scope-sdk';
 import { Fraction } from './fraction';
 import { chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
 import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
@@ -59,6 +59,8 @@ export class KaminoMarket {
 
   readonly programId: PublicKey;
 
+  scope: Scope;
+
   private readonly recentSlotDurationMs: number;
 
   private constructor(
@@ -66,6 +68,7 @@ export class KaminoMarket {
     state: LendingMarket,
     marketAddress: string,
     reserves: Map<PublicKey, KaminoReserve>,
+    scope: Scope,
     recentSlotDurationMs: number,
     programId: PublicKey = PROGRAM_ID
   ) {
@@ -75,6 +78,7 @@ export class KaminoMarket {
     this.reserves = reserves;
     this.reservesActive = getReservesActive(this.reserves);
     this.programId = programId;
+    this.scope = scope;
     this.recentSlotDurationMs = recentSlotDurationMs;
   }
 
@@ -93,6 +97,7 @@ 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);
@@ -100,12 +105,26 @@ 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, recentSlotDurationMs, programId);
+    return new KaminoMarket(
+      connection,
+      market,
+      marketAddress.toString(),
+      reserves,
+      scope,
+      recentSlotDurationMs,
+      programId
+    );
   }
 
   async reload(): Promise<void> {
@@ -1167,9 +1186,9 @@ export class KaminoMarket {
   /**
    * Get all Scope prices used by all the market reserves
    */
-  async getAllScopePrices(scope: Scope, oraclePrices?: OraclePrices): Promise<KaminoPrices> {
+  async getAllScopePrices(oraclePrices?: OraclePrices): Promise<KaminoPrices> {
     if (!oraclePrices) {
-      oraclePrices = await scope.getOraclePrices();
+      oraclePrices = await this.scope.getOraclePrices();
     }
     const spot: MintToPriceMap = {};
     const twaps: MintToPriceMap = {};
@@ -1180,11 +1199,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 scope.getPriceFromChain(chain, oraclePrices);
+        const spotPrice = await this.scope.getPriceFromChain(chain, oraclePrices);
         spot[tokenMint] = { price: spotPrice.price, name: tokenName };
       }
       if (oracle && isNotNullPubkey(oracle) && twapChain && Scope.isScopeChainValid(twapChain)) {
-        const twap = await scope.getPriceFromChain(twapChain, oraclePrices);
+        const twap = await this.scope.getPriceFromChain(twapChain, oraclePrices);
         twaps[tokenMint] = { price: twap.price, name: tokenName };
       }
     }
@@ -1508,34 +1527,6 @@ 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,7 +17,6 @@ import {
   getObligationPdaWithArgs,
   getObligationType,
   isNotNullPubkey,
-  ObligationType,
   PubkeyHashMap,
   TOTAL_NUMBER_OF_IDS_TO_CHECK,
   U64_MAX,
@@ -267,7 +266,7 @@ export class KaminoObligation {
   /**
    * @returns total borrow power of the obligation, relative to max LTV of each asset's reserve
    */
-  getMaxAllowedBorrowValue(): Decimal {
+  getAllowedBorrowValue(): Decimal {
     return new Fraction(this.state.allowedBorrowValueSf).toDecimal();
   }
 
@@ -1594,8 +1593,3 @@ 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/vault.ts

@@ -11,7 +11,7 @@ import {
   SYSVAR_RENT_PUBKEY,
   TransactionInstruction,
 } from '@solana/web3.js';
-import { getAssociatedTokenAddressSync, NATIVE_MINT, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
+import { NATIVE_MINT, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
 import {
   getAssociatedTokenAddress,
   getTransferWsolIxns,
@@ -82,7 +82,7 @@ import {
 import { batchFetch, collToLamportsDecimal, ZERO } from '@kamino-finance/kliquidity-sdk';
 import { FullBPSDecimal } from '@kamino-finance/kliquidity-sdk/dist/utils/CreationParameters';
 import { FarmState } from '@kamino-finance/farms-sdk/dist';
-import { getAccountsInLUT, initLookupTableIx } from '../utils/lookupTable';
+import { getAccountsInLUT, initLookupTableIx } from './lut_utils';
 import {
   getFarmStakeIxs,
   getFarmUnstakeAndWithdrawIxs,
@@ -100,8 +100,6 @@ 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.
  */
@@ -197,8 +195,6 @@ export class KaminoVaultClient {
       this._kaminoVaultProgramId
     )[0];
 
-    const adminTokenAccount = getAssociatedTokenAddressSync(vaultConfig.tokenMint, vaultConfig.admin, false);
-
     const initVaultAccounts: InitVaultAccounts = {
       adminAuthority: vaultConfig.admin,
       vaultState: vaultState.publicKey,
@@ -210,7 +206,6 @@ export class KaminoVaultClient {
       rent: SYSVAR_RENT_PUBKEY,
       tokenProgram: vaultConfig.tokenMintProgramId,
       sharesTokenProgram: TOKEN_PROGRAM_ID,
-      adminTokenAccount,
     };
     const initVaultIx = initVault(initVaultAccounts, this._kaminoVaultProgramId);
 
@@ -293,7 +288,7 @@ export class KaminoVaultClient {
     );
 
     const updateReserveAllocationAccounts: UpdateReserveAllocationAccounts = {
-      signer: vaultState.vaultAdminAuthority,
+      adminAuthority: vaultState.adminAuthority,
       vaultState: vault.address,
       baseVaultAuthority: vaultState.baseVaultAuthority,
       reserveCollateralMint: reserveState.collateral.mintPubkey,
@@ -301,7 +296,7 @@ export class KaminoVaultClient {
       ctokenVault: cTokenVault,
       systemProgram: SystemProgram.programId,
       rent: SYSVAR_RENT_PUBKEY,
-      reserveCollateralTokenProgram: TOKEN_PROGRAM_ID,
+      reserveCollateralTokenProgram: vaultState.tokenProgram,
     };
 
     const updateReserveAllocationArgs: UpdateReserveAllocationArgs = {
@@ -325,7 +320,7 @@ export class KaminoVaultClient {
     accountsToAddToLUT.push(lendingMarketAuth);
 
     const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(
-      vaultState.vaultAdminAuthority,
+      vaultState.adminAuthority,
       vaultState.vaultLookupTable,
       accountsToAddToLUT
     );
@@ -355,12 +350,12 @@ export class KaminoVaultClient {
     const vaultState: VaultState = await vault.getState(this.getConnection());
 
     const updateVaultConfigAccs: UpdateVaultConfigAccounts = {
-      vaultAdminAuthority: vaultState.vaultAdminAuthority,
+      adminAuthority: vaultState.adminAuthority,
       vaultState: vault.address,
       klendProgram: this._kaminoLendProgramId,
     };
     if (signer) {
-      updateVaultConfigAccs.vaultAdminAuthority = signer;
+      updateVaultConfigAccs.adminAuthority = signer;
     }
 
     const updateVaultConfigArgs: UpdateVaultConfigArgs = {
@@ -414,7 +409,7 @@ export class KaminoVaultClient {
     if (mode.kind === new VaultConfigField.PendingVaultAdmin().kind) {
       const newPubkey = new PublicKey(value);
       const insertIntoLutIxs = await this.insertIntoLookupTableIxs(
-        vaultState.vaultAdminAuthority,
+        vaultState.adminAuthority,
         vaultState.vaultLookupTable,
         [newPubkey]
       );
@@ -432,7 +427,7 @@ export class KaminoVaultClient {
           farmState!.globalConfig
         );
         const insertIntoLutIxs = await this.insertIntoLookupTableIxs(
-          vaultState.vaultAdminAuthority,
+          vaultState.adminAuthority,
           vaultState.vaultLookupTable,
           keysToAddToLUT
         );
@@ -481,7 +476,7 @@ export class KaminoVaultClient {
     value: string
   ): TransactionInstruction {
     const updateVaultConfigAccs: UpdateVaultConfigAccounts = {
-      vaultAdminAuthority: admin,
+      adminAuthority: admin,
       vaultState: vault,
       klendProgram: this._kaminoLendProgramId,
     };
@@ -531,7 +526,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.vaultAdminAuthority)
+      (account) => !account.equals(vaultState.adminAuthority)
     );
 
     const LUTIxs: TransactionInstruction[] = [];
@@ -574,7 +569,7 @@ export class KaminoVaultClient {
     const vaultState: VaultState = await vault.getState(this.getConnection());
 
     const giveUpPendingFeesAccounts: GiveUpPendingFeesAccounts = {
-      vaultAdminAuthority: vaultState.vaultAdminAuthority,
+      adminAuthority: vaultState.adminAuthority,
       vaultState: vault.address,
       klendProgram: this._kaminoLendProgramId,
     };
@@ -604,7 +599,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.vaultAdminAuthority, [
+    const [{ ata: adminTokenAta, createAtaIx }] = createAtasIdempotent(vaultState.adminAuthority, [
       {
         mint: vaultState.tokenMint,
         tokenProgram: TOKEN_PROGRAM_ID,
@@ -1015,16 +1010,20 @@ 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[] = [];
 
@@ -1295,7 +1294,7 @@ export class KaminoVaultClient {
     const lendingMarketAuth = lendingMarketAuthPda(marketAddress, this._kaminoLendProgramId)[0];
 
     const withdrawPendingFeesAccounts: WithdrawPendingFeesAccounts = {
-      vaultAdminAuthority: vaultState.vaultAdminAuthority,
+      adminAuthority: vaultState.adminAuthority,
       vaultState: vault.address,
       reserve: reserve.address,
       tokenVault: vaultState.tokenVault,
@@ -1355,7 +1354,7 @@ export class KaminoVaultClient {
     const vaultState = await vault.getState(this.getConnection());
     const allAccountsToBeInserted = [
       vault.address,
-      vaultState.vaultAdminAuthority,
+      vaultState.adminAuthority,
       vaultState.baseVaultAuthority,
       vaultState.tokenMint,
       vaultState.tokenVault,
@@ -1400,7 +1399,7 @@ export class KaminoVaultClient {
     let lut = vaultState.vaultLookupTable;
     if (lut.equals(PublicKey.default)) {
       const recentSlot = await this.getConnection().getSlot();
-      const [ixn, address] = initLookupTableIx(vaultState.vaultAdminAuthority, recentSlot);
+      const [ixn, address] = initLookupTableIx(vaultState.adminAuthority, recentSlot);
       setupLUTIfNeededIxs.push(ixn);
       lut = address;
 
@@ -1420,7 +1419,7 @@ export class KaminoVaultClient {
     }
     ixns.push(
       ...(await this.insertIntoLookupTableIxs(
-        vaultState.vaultAdminAuthority,
+        vaultState.adminAuthority,
         lut,
         allAccountsToBeInserted,
         overridenExistentAccounts
@@ -1529,8 +1528,8 @@ export class KaminoVaultClient {
 
     let totalLeftToInvest = holdings.totalAUMIncludingFees.sub(holdings.pendingFees);
     let currentAllocationSum = totalAllocation;
-    const ONE = new Decimal(1);
-    while (totalLeftToInvest.gt(ONE)) {
+    const ZERO = new Decimal(0);
+    while (totalLeftToInvest.gt(ZERO)) {
       const totalLeftover = totalLeftToInvest;
       for (const reserve of allReserves) {
         const reserveWithWeight = initialVaultAllocations.get(reserve);

package/src/client.ts

@@ -22,7 +22,6 @@ 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');
@@ -310,8 +309,7 @@ async function deposit(connection: Connection, wallet: Keypair, token: string, d
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
     new VanillaObligation(STAGING_LENDING_MARKET),
-    true,
-    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
+    true
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -332,8 +330,7 @@ async function withdraw(connection: Connection, wallet: Keypair, token: string,
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
-    true,
-    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
+    true
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -354,8 +351,7 @@ async function borrow(connection: Connection, wallet: Keypair, token: string, bo
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
-    true,
-    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
+    true
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -377,7 +373,6 @@ 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/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 {
-  vaultAdminAuthority: PublicKey
+  adminAuthority: PublicKey
   baseVaultAuthority: PublicKey
   baseVaultAuthorityBump: BN
   tokenMint: PublicKey
@@ -38,12 +38,11 @@ export interface VaultStateFields {
   vaultFarm: PublicKey
   creationTimestamp: BN
   padding1: BN
-  allocationAdmin: PublicKey
   padding2: Array<BN>
 }
 
 export interface VaultStateJSON {
-  vaultAdminAuthority: string
+  adminAuthority: string
   baseVaultAuthority: string
   baseVaultAuthorityBump: string
   tokenMint: string
@@ -76,12 +75,11 @@ export interface VaultStateJSON {
   vaultFarm: string
   creationTimestamp: string
   padding1: string
-  allocationAdmin: string
   padding2: Array<string>
 }
 
 export class VaultState {
-  readonly vaultAdminAuthority: PublicKey
+  readonly adminAuthority: PublicKey
   readonly baseVaultAuthority: PublicKey
   readonly baseVaultAuthorityBump: BN
   readonly tokenMint: PublicKey
@@ -114,7 +112,6 @@ export class VaultState {
   readonly vaultFarm: PublicKey
   readonly creationTimestamp: BN
   readonly padding1: BN
-  readonly allocationAdmin: PublicKey
   readonly padding2: Array<BN>
 
   static readonly discriminator = Buffer.from([
@@ -122,7 +119,7 @@ export class VaultState {
   ])
 
   static readonly layout = borsh.struct([
-    borsh.publicKey("vaultAdminAuthority"),
+    borsh.publicKey("adminAuthority"),
     borsh.publicKey("baseVaultAuthority"),
     borsh.u64("baseVaultAuthorityBump"),
     borsh.publicKey("tokenMint"),
@@ -155,12 +152,11 @@ export class VaultState {
     borsh.publicKey("vaultFarm"),
     borsh.u64("creationTimestamp"),
     borsh.u64("padding1"),
-    borsh.publicKey("allocationAdmin"),
-    borsh.array(borsh.u128(), 242, "padding2"),
+    borsh.array(borsh.u128(), 244, "padding2"),
   ])
 
   constructor(fields: VaultStateFields) {
-    this.vaultAdminAuthority = fields.vaultAdminAuthority
+    this.adminAuthority = fields.adminAuthority
     this.baseVaultAuthority = fields.baseVaultAuthority
     this.baseVaultAuthorityBump = fields.baseVaultAuthorityBump
     this.tokenMint = fields.tokenMint
@@ -195,7 +191,6 @@ export class VaultState {
     this.vaultFarm = fields.vaultFarm
     this.creationTimestamp = fields.creationTimestamp
     this.padding1 = fields.padding1
-    this.allocationAdmin = fields.allocationAdmin
     this.padding2 = fields.padding2
   }
 
@@ -243,7 +238,7 @@ export class VaultState {
     const dec = VaultState.layout.decode(data.slice(8))
 
     return new VaultState({
-      vaultAdminAuthority: dec.vaultAdminAuthority,
+      adminAuthority: dec.adminAuthority,
       baseVaultAuthority: dec.baseVaultAuthority,
       baseVaultAuthorityBump: dec.baseVaultAuthorityBump,
       tokenMint: dec.tokenMint,
@@ -280,14 +275,13 @@ export class VaultState {
       vaultFarm: dec.vaultFarm,
       creationTimestamp: dec.creationTimestamp,
       padding1: dec.padding1,
-      allocationAdmin: dec.allocationAdmin,
       padding2: dec.padding2,
     })
   }
 
   toJSON(): VaultStateJSON {
     return {
-      vaultAdminAuthority: this.vaultAdminAuthority.toString(),
+      adminAuthority: this.adminAuthority.toString(),
       baseVaultAuthority: this.baseVaultAuthority.toString(),
       baseVaultAuthorityBump: this.baseVaultAuthorityBump.toString(),
       tokenMint: this.tokenMint.toString(),
@@ -322,14 +316,13 @@ 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({
-      vaultAdminAuthority: new PublicKey(obj.vaultAdminAuthority),
+      adminAuthority: new PublicKey(obj.adminAuthority),
       baseVaultAuthority: new PublicKey(obj.baseVaultAuthority),
       baseVaultAuthorityBump: new BN(obj.baseVaultAuthorityBump),
       tokenMint: new PublicKey(obj.tokenMint),
@@ -364,7 +357,6 @@ 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)),
     })
   }