@kamino-finance/klend-sdk 7.2.6 → 7.3.0

package/src/lib.ts

@@ -4,7 +4,8 @@ export * from './@codegen/klend/programId';
 export * from './@codegen/klend/zero_padding';
 
 export * from './@codegen/kvault/instructions';
-// only export vault state, do not export Reserve as it's the same one in main klend /@codegen/klend/accounts
+// only export vault state and global config, do not export Reserve as it's the same one in main klend /@codegen/klend/accounts
+export { GlobalConfig as KVaultGlobalConfig } from './@codegen/kvault/accounts/GlobalConfig';
 export * from './@codegen/kvault/accounts/VaultState';
 export * from './@codegen/kvault/types';
 export { PROGRAM_ID as KVAULTS_PROGRAM_ID } from './@codegen/kvault/programId';

package/src/manager/client_kamino_manager.ts

@@ -1,6 +1,6 @@
 import dotenv from 'dotenv';
 import { Command } from 'commander';
-import { Address, address, Instruction } from '@solana/kit';
+import { Address, address, Instruction, TransactionSigner } from '@solana/kit';
 import {
   AssetReserveConfigCli,
   calculateAPYFromAPR,
@@ -19,7 +19,10 @@ import {
   KaminoVaultConfig,
   lamportsToDecimal,
   LendingMarket,
+  parseBooleanFlag,
+  parseTokenSymbol,
   parseZeroPaddedUtf8,
+  programDataPda,
   Reserve,
   ReserveAllocationConfig,
   ReserveWithAddress,
@@ -38,7 +41,7 @@ import {
 import { Fraction } from '../classes/fraction';
 import Decimal from 'decimal.js';
 import BN from 'bn.js';
-import { PythConfiguration, SwitchboardConfiguration } from '../@codegen/kvault/types';
+import { PythConfiguration, SwitchboardConfiguration, UpdateReserveWhitelistMode } from '../@codegen/kvault/types';
 import * as fs from 'fs';
 import { MarketWithAddress } from '../utils/managerTypes';
 import { ManagementFeeBps, PendingVaultAdmin, PerformanceFeeBps } from '../@codegen/kvault/types/VaultConfigField';
@@ -72,7 +75,7 @@ async function main() {
         throw new Error('If using multisig mode, multisig pubkey is required');
       }
       const ms = multisig ? address(multisig) : undefined;
-      const env = await initEnv(ms, staging);
+      const env = await initEnv(staging, ms);
       const admin = await env.getSigner();
 
       const kaminoManager = new KaminoManager(
@@ -303,6 +306,59 @@ async function main() {
       );
     });
 
+  commands
+    .command('init-kvault-global-config')
+    .requiredOption(
+      '--mode <string>',
+      'simulate|multisig|execute - simulate - to print txn simulation and to get tx simulation link in explorer, execute - execute tx, multisig - to get bs58 tx for multisig usage'
+    )
+    .option(`--staging`, 'If true, will use the staging programs')
+    .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+    .option('--signer-path <string>', 'If set, it will use the provided signer')
+    .action(async ({ mode, staging, multisig, signerPath }) => {
+      if (mode === 'multisig' && !multisig) {
+        throw new Error('If using multisig mode, multisig is required');
+      }
+      const ms = multisig ? address(multisig) : undefined;
+      const env = await initEnv(staging, ms, signerPath);
+      const kaminoManager = new KaminoManager(
+        env.c.rpc,
+        DEFAULT_RECENT_SLOT_DURATION_MS,
+        env.klendProgramId,
+        env.kvaultProgramId
+      );
+
+      let signer: TransactionSigner | undefined = undefined;
+      if (signerPath) {
+        signer = await parseKeypairFile(signerPath);
+      } else {
+        const programData = await programDataPda(env.kvaultProgramId);
+        const programDataInfo = await env.c.rpc.getAccountInfo(programData).send();
+        if (programDataInfo === null) {
+          throw new Error('KVault program data not found');
+        }
+        const programAdmin = programDataInfo.value?.owner.toString();
+        if (!programAdmin) {
+          throw new Error('Program admin not found');
+        }
+        signer = noopSigner(address(programAdmin));
+      }
+      const ix = await kaminoManager.initKvaultGlobalConfigIx(signer);
+      await processTx(
+        env.c,
+        signer,
+        [
+          ix,
+          ...getPriorityFeeAndCuIxs({
+            priorityFeeMultiplier: 2500,
+          }),
+        ],
+        mode,
+        []
+      );
+      mode === 'execute' && console.log('KVault global config initialized');
+    });
+
   commands
     .command('create-vault')
     .requiredOption('--mint <string>', 'Vault token mint')
@@ -508,8 +564,18 @@ async function main() {
       `--lutSigner <string>`,
       'If set, it will use the provided signer instead of the default one for the LUT update'
     )
-    .action(async ({ vault, field, value, mode, staging, skipLutUpdate, lutSigner }) => {
-      const env = await initEnv(staging);
+    .option(
+      `--global-admin <string>`,
+      'Global admin signer (keypair path in execute/simulate modes, pubkey in multisig mode). Required when setting AllowInvestInWhitelistedReservesOnly or AllowAllocationsInWhitelistedReservesOnly to false'
+    )
+    .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+    .action(async ({ vault, field, value, mode, staging, skipLutUpdate, lutSigner, globalAdmin, multisig }) => {
+      if (mode === 'multisig' && !multisig) {
+        throw new Error('If using multisig mode, multisig pubkey is required');
+      }
+
+      const ms = multisig ? address(multisig) : undefined;
+      const env = await initEnv(staging, ms);
       const vaultAddress = address(vault);
 
       const kaminoManager = new KaminoManager(
@@ -521,7 +587,16 @@ async function main() {
 
       const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
       const vaultState = await kaminoVault.getState();
-      const signer = await env.getSigner({ vaultState });
+
+      // Use global admin signer if provided, otherwise fall back to vault admin/noop signer depending on mode
+      let signer;
+      if (mode === 'multisig' && globalAdmin) {
+        signer = noopSigner(address(globalAdmin));
+      } else if (globalAdmin) {
+        signer = await parseKeypairFile(globalAdmin as string);
+      } else {
+        signer = await env.getSigner({ vaultState });
+      }
 
       let lutSignerOrUndefined = undefined;
       if (lutSigner) {
@@ -555,10 +630,226 @@ async function main() {
       mode === 'execute' && console.log('Vault updated');
     });
 
+  commands
+    .command('add-update-whitelisted-reserve')
+    .requiredOption('--reserve <string>', 'Reserve address to whitelist')
+    .requiredOption('--whitelist-mode <string>', 'Whitelist mode: "Invest" or "AddAllocation"')
+    .requiredOption(
+      '--value <string>',
+      'Value: "1" or "true" to add to whitelist, "0" or "false" to remove from whitelist'
+    )
+    .requiredOption(
+      `--mode <string>`,
+      'simulate|multisig|execute - simulate - to print txn simulation and to get tx simulation link in explorer, execute - execute tx, multisig - to get bs58 tx for multisig usage'
+    )
+    .requiredOption(
+      '--global-admin <string>',
+      'Global admin signer (keypair path in execute/simulate modes, pubkey in multisig mode)'
+    )
+    .option(`--staging`, 'If true, will use the staging programs')
+    .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+    .action(async ({ reserve, whitelistMode, value, mode, globalAdmin, staging, multisig }) => {
+      if (mode === 'multisig' && !multisig) {
+        throw new Error('If using multisig mode, multisig pubkey is required');
+      }
+
+      const ms = multisig ? address(multisig) : undefined;
+      const env = await initEnv(staging, ms);
+      const reserveAddress = address(reserve);
+
+      const kaminoManager = new KaminoManager(
+        env.c.rpc,
+        DEFAULT_RECENT_SLOT_DURATION_MS,
+        env.klendProgramId,
+        env.kvaultProgramId
+      );
+
+      // Parse the value (1/true = add, 0/false = remove)
+      const flagValue = parseBooleanFlag(value);
+
+      // Parse the whitelist mode
+      let whitelistModeEnum;
+      if (whitelistMode === 'Invest') {
+        whitelistModeEnum = new UpdateReserveWhitelistMode.Invest([flagValue]);
+      } else if (whitelistMode === 'AddAllocation') {
+        whitelistModeEnum = new UpdateReserveWhitelistMode.AddAllocation([flagValue]);
+      } else {
+        throw new Error(`Invalid whitelist mode '${whitelistMode}'. Expected 'Invest' or 'AddAllocation'.`);
+      }
+
+      let globalAdminSigner;
+      if (mode === 'multisig') {
+        globalAdminSigner = noopSigner(address(globalAdmin));
+      } else {
+        globalAdminSigner = await parseKeypairFile(globalAdmin as string);
+      }
+
+      const instruction = await kaminoManager.addUpdateWhitelistedReserveIx(
+        reserveAddress,
+        whitelistModeEnum,
+        globalAdminSigner
+      );
+
+      await processTx(
+        env.c,
+        globalAdminSigner,
+        [
+          instruction,
+          ...getPriorityFeeAndCuIxs({
+            priorityFeeMultiplier: 2500,
+          }),
+        ],
+        mode,
+        []
+      );
+
+      mode === 'execute' &&
+        console.log(
+          `Reserve ${reserveAddress} whitelisted for ${whitelistMode} with value ${flagValue ? 'ALLOW' : 'DENY'}`
+        );
+    });
+
+  commands
+    .command('backfill-whitelisted-reserves')
+    .option(
+      '--value <string>',
+      'Value: "1" or "true" to add to whitelist, "0" or "false" to remove from whitelist',
+      '1'
+    )
+    .requiredOption(
+      `--mode <string>`,
+      'simulate|multisig|execute - simulate - to print txn simulation and to get tx simulation link in explorer, execute - execute tx, multisig - to get bs58 tx for multisig usage'
+    )
+    .requiredOption(
+      '--global-admin <string>',
+      'Global admin signer (keypair path in execute/simulate modes, pubkey in multisig mode)'
+    )
+    .option(
+      `--markets <string>`,
+      'Comma-separated list of market addresses. If not provided, all markets will be processed'
+    )
+    .option(`--staging`, 'If true, will use the staging programs')
+    .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+    .action(async ({ value, mode, globalAdmin, markets, staging, multisig }) => {
+      if (mode === 'multisig' && !multisig) {
+        throw new Error('If using multisig mode, multisig pubkey is required');
+      }
+
+      const ms = multisig ? address(multisig) : undefined;
+      const env = await initEnv(staging, ms);
+
+      const kaminoManager = new KaminoManager(
+        env.c.rpc,
+        DEFAULT_RECENT_SLOT_DURATION_MS,
+        env.klendProgramId,
+        env.kvaultProgramId
+      );
+
+      let globalAdminSigner;
+      if (mode === 'multisig') {
+        globalAdminSigner = noopSigner(address(globalAdmin));
+      } else {
+        globalAdminSigner = await parseKeypairFile(globalAdmin as string);
+      }
+
+      // Get markets to process
+      let marketsToProcess: KaminoMarket[];
+      if (markets) {
+        const marketAddresses = markets.split(',').map((m: string) => address(m.trim()));
+        console.log(`Processing ${marketAddresses.length} specified markets...`);
+        marketsToProcess = await Promise.all(
+          marketAddresses.map(async (marketAddress: Address) => {
+            const market = await KaminoMarket.load(
+              env.c.rpc,
+              marketAddress,
+              DEFAULT_RECENT_SLOT_DURATION_MS,
+              env.klendProgramId
+            );
+            if (!market) {
+              throw new Error(`Market ${marketAddress} not found`);
+            }
+            return market;
+          })
+        );
+      } else {
+        console.log('Fetching all markets...');
+        marketsToProcess = await kaminoManager.getAllMarkets(env.klendProgramId);
+        console.log(`Found ${marketsToProcess.length} markets`);
+      }
+
+      // Collect all reserves from all markets
+      const allReserves: Address[] = [];
+      for (const market of marketsToProcess) {
+        const marketName = parseTokenSymbol(market.state.name);
+        const reserveAddresses = Array.from(market.reserves.keys());
+        console.log(`Market ${market.getAddress()} (${marketName}): ${reserveAddresses.length} reserves`);
+        allReserves.push(...reserveAddresses);
+      }
+
+      console.log(`\nTotal reserves to whitelist: ${allReserves.length}`);
+      console.log(`Whitelist modes: Invest AND AddAllocation (both will be set)`);
+
+      // Parse the value (1/true = add, 0/false = remove)
+      const flagValue = parseBooleanFlag(value);
+      console.log(`Action: ${flagValue ? 'ADD to whitelist' : 'REMOVE from whitelist'}`);
+
+      if (mode === 'simulate') {
+        console.log('\nSimulation mode - no transactions will be executed');
+      }
+
+      // Create whitelist mode enums for both Invest and AddAllocation
+      const investModeEnum = new UpdateReserveWhitelistMode.Invest([flagValue]);
+      const addAllocationModeEnum = new UpdateReserveWhitelistMode.AddAllocation([flagValue]);
+
+      // Process each reserve with both whitelist modes
+      let successCount = 0;
+      let errorCount = 0;
+
+      for (const reserveAddress of allReserves) {
+        try {
+          const investInstruction = await kaminoManager.addUpdateWhitelistedReserveIx(
+            reserveAddress,
+            investModeEnum,
+            globalAdminSigner
+          );
+
+          const addAllocationInstruction = await kaminoManager.addUpdateWhitelistedReserveIx(
+            reserveAddress,
+            addAllocationModeEnum,
+            globalAdminSigner
+          );
+
+          await processTx(
+            env.c,
+            globalAdminSigner,
+            [
+              investInstruction,
+              addAllocationInstruction,
+              ...getPriorityFeeAndCuIxs({
+                priorityFeeMultiplier: 2500,
+              }),
+            ],
+            mode,
+            []
+          );
+
+          successCount++;
+          console.log(`✓ [${successCount}/${allReserves.length}] ${reserveAddress} (Invest + AddAllocation)`);
+        } catch (error) {
+          errorCount++;
+          console.error(`✗ Failed to whitelist ${reserveAddress}:`, error);
+        }
+      }
+
+      console.log(`\nBackfill complete!`);
+      console.log(`Success: ${successCount} reserves (both modes set)`);
+      console.log(`Errors: ${errorCount}`);
+    });
+
   commands
     .command('update-vault-mgmt-fee')
     .requiredOption('--vault <string>', 'Vault address')
-    .requiredOption('--fee-bps <string>', 'Pubkey of the new admin')
+    .requiredOption('--fee-bps <string>', 'Management fee to set (in basis points)')
     .requiredOption(
       `--mode <string>`,
       'simulate|multisig|execute - simulate - to print txn simulation and to get tx simulation link in explorer, execute - execute tx, multisig - to get bs58 tx for multisig usage'
@@ -614,7 +905,11 @@ async function main() {
     .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
     .option(`--signer <string>`, 'If set, it will use the provided signer instead of the default one')
     .action(async ({ lut, addresses, mode, staging, multisig, signer }) => {
-      const env = await initEnv(multisig, staging);
+      if (mode === 'multisig' && !multisig) {
+        throw new Error('If using multisig mode, multisig is required');
+      }
+      const ms = multisig ? address(multisig) : undefined;
+      const env = await initEnv(staging, ms);
       const lutAddress = address(lut);
       let txSigner = await env.getSigner();
       // if the signer is provided (path to a keypair) we use it, otherwise we use the default one
@@ -623,10 +918,6 @@ async function main() {
       }
       const addressesArr = addresses.split(' ').map((a: string) => address(a));
 
-      if (mode === 'multisig' && !multisig) {
-        throw new Error('If using multisig mode, multisig is required');
-      }
-
       const kaminoManager = new KaminoManager(
         env.c.rpc,
         DEFAULT_RECENT_SLOT_DURATION_MS,
@@ -739,7 +1030,7 @@ async function main() {
   commands
     .command('update-vault-perf-fee')
     .requiredOption('--vault <string>', 'Vault address')
-    .requiredOption('--fee-bps <string>', 'Pubkey of the new admin')
+    .requiredOption('--fee-bps <string>', 'Performance fee to set (in basis points)')
     .requiredOption(
       `--mode <string>`,
       'simulate|multisig|execute - simulate - to print txn simulation and to get tx simulation link in explorer, execute - execute tx, multisig - to get bs58 tx for multisig usage'
@@ -1139,7 +1430,8 @@ async function main() {
       if (mode === 'multisig' && !multisig) {
         throw new Error('If using multisig mode, multisig is required');
       }
-      const env = await initEnv(staging, multisig);
+      const ms = multisig ? address(multisig) : undefined;
+      const env = await initEnv(staging, ms);
       const vaultAddress = address(vault);
 
       const kaminoManager = new KaminoManager(
@@ -1185,7 +1477,8 @@ async function main() {
       if (mode === 'multisig' && !multisig) {
         throw new Error('If using multisig mode, multisig is required');
       }
-      const env = await initEnv(multisig, staging);
+      const ms = multisig ? address(multisig) : undefined;
+      const env = await initEnv(staging, ms);
       const signer = await env.getSigner();
       const vaultAddress = address(vault);
 
@@ -2157,7 +2450,7 @@ function parseReserveConfigFromFile(reserveConfigFromFile: any): ReserveConfig {
     maxLiquidationBonusBps: reserveConfigFromFile.maxLiquidationBonusBps,
     badDebtLiquidationBonusBps: reserveConfigFromFile.badDebtLiquidationBonusBps,
     fees: {
-      borrowFeeSf: Fraction.fromDecimal(new Decimal(reserveConfigFromFile.fees.borrowFee)).valueSf,
+      originationFeeSf: Fraction.fromDecimal(new Decimal(reserveConfigFromFile.fees.borrowFee)).valueSf,
       flashLoanFeeSf: Fraction.fromDecimal(new Decimal(reserveConfigFromFile.fees.flashLoanFee)).valueSf,
       padding: Array(8).fill(0),
     },
@@ -2203,7 +2496,9 @@ function parseReserveConfigFromFile(reserveConfigFromFile: any): ReserveConfig {
     borrowLimitAgainstThisCollateralInElevationGroup: parseReserveBorrowLimitAgainstCollInEmode(reserveConfigFromFile),
     deleveragingBonusIncreaseBpsPerDay: new BN(reserveConfigFromFile.deleveragingBonusIncreaseBpsPerDay),
     reserved1: Array(1).fill(0),
-    reserved2: Array(9).fill(0),
+    minDeleveragingBonusBps: 0,
+    proposerAuthorityLocked: 0,
+    blockCtokenUsage: 0,
   };
 
   return new ReserveConfig(reserveConfigFields);
@@ -2287,7 +2582,7 @@ function parseReserveConfigToFile(reserveConfig: ReserveConfig) {
     maxLiquidationBonusBps: reserveConfig.maxLiquidationBonusBps,
     badDebtLiquidationBonusBps: reserveConfig.badDebtLiquidationBonusBps,
     fees: {
-      borrowFee: new Fraction(reserveConfig.fees.borrowFeeSf).toDecimal().toString(),
+      borrowFee: new Fraction(reserveConfig.fees.originationFeeSf).toDecimal().toString(),
       flashLoanFee: new Fraction(reserveConfig.fees.flashLoanFeeSf).toDecimal().toString(),
       padding: Array(8).fill(0),
     },

package/src/utils/index.ts

@@ -15,4 +15,5 @@ export * from './managerTypes';
 export * from './fuzz';
 export * from './rpc';
 export * from './map';
-export * from './obligations'
+export * from './parse';
+export * from './obligations';

package/src/utils/managerTypes.ts

@@ -243,7 +243,7 @@ export type AssetReserveConfigParams = {
   minLiquidationBonusBps: number;
   badDebtLiquidationBonusBps: number;
   liquidationThresholdPct: number;
-  borrowFeeSf: Fraction;
+  originationFeeSf: Fraction;
   flashLoanFeeSf: Fraction;
   protocolTakeRate: number;
   elevationGroups: number[];
@@ -260,7 +260,7 @@ export const getDefaultConfigParams = (): AssetReserveConfigParams => {
     minLiquidationBonusBps: 200,
     badDebtLiquidationBonusBps: 10,
     liquidationThresholdPct: 75,
-    borrowFeeSf: ZERO_FRACTION,
+    originationFeeSf: ZERO_FRACTION,
     flashLoanFeeSf: ZERO_FRACTION,
     protocolTakeRate: 0,
     elevationGroups: new Array(20).fill(0),
@@ -310,7 +310,7 @@ function buildReserveConfig(fields: {
     maxLiquidationBonusBps: fields.configParams.maxLiquidationBonusBps,
     badDebtLiquidationBonusBps: fields.configParams.badDebtLiquidationBonusBps,
     fees: {
-      borrowFeeSf: fields.configParams.borrowFeeSf.getValue(),
+      originationFeeSf: fields.configParams.originationFeeSf.getValue(),
       flashLoanFeeSf: fields.configParams.flashLoanFeeSf.getValue(),
       padding: Array(6).fill(0),
     },
@@ -370,7 +370,9 @@ function buildReserveConfig(fields: {
     borrowLimitAgainstThisCollateralInElevationGroup: Array(32).fill(new BN(0)),
     deleveragingBonusIncreaseBpsPerDay: new BN(100),
     reserved1: Array(1).fill(0),
-    reserved2: Array(9).fill(0),
+    minDeleveragingBonusBps: 0,
+    proposerAuthorityLocked: 0,
+    blockCtokenUsage: 0,
   };
 
   return new ReserveConfig(reserveConfigFields);

package/src/utils/parse.ts

@@ -0,0 +1,18 @@
+/**
+ * Parses a boolean-like string value ("true", "false", "1", "0") into a number (0 or 1).
+ * Used for vault configuration flags like whitelist settings.
+ *
+ * @param value - The string value to parse (case-insensitive)
+ * @returns 1 for truthy values ("true" or "1"), 0 for falsy values ("false" or "0")
+ * @throws Error if the value is not one of the expected values
+ */
+export function parseBooleanFlag(value: string): number {
+  const normalizedValue = value.toLowerCase();
+  if (normalizedValue === 'true' || normalizedValue === '1') {
+    return 1;
+  } else if (normalizedValue === 'false' || normalizedValue === '0') {
+    return 0;
+  } else {
+    throw new Error(`Invalid value '${value}'. Expected 'true', 'false', '1', or '0'.`);
+  }
+}

package/src/utils/seeds.ts

@@ -73,12 +73,12 @@ export interface ReservePdas {
  * @param mint
  * @returns ReservePdas
  */
-export async function reservePdas(programId: Address, market: Address, mint: Address): Promise<ReservePdas> {
+export async function reservePdas(programId: Address, reserve: Address): Promise<ReservePdas> {
   const [[liquiditySupplyVault], [collateralMint], [collateralSupplyVault], [feeVault]] = await Promise.all([
-    reserveLiqSupplyPda(market, mint, programId),
-    reserveCollateralMintPda(market, mint, programId),
-    reserveCollateralSupplyPda(market, mint, programId),
-    reserveFeeVaultPda(market, mint, programId),
+    reserveLiqSupplyPda(reserve, programId),
+    reserveCollateralMintPda(reserve, programId),
+    reserveCollateralSupplyPda(reserve, programId),
+    reserveFeeVaultPda(reserve, programId),
   ]);
   return {
     liquiditySupplyVault,
@@ -112,12 +112,11 @@ export function lendingMarketAuthPda(
  * @returns [pda, bump]
  */
 export async function reserveLiqSupplyPda(
-  lendingMarket: Address,
-  mint: Address,
+  reserve: Address,
   programId: Address = PROGRAM_ID
 ): Promise<ProgramDerivedAddress> {
   return getProgramDerivedAddress({
-    seeds: [Buffer.from(RESERVE_LIQ_SUPPLY_SEED), addressEncoder.encode(lendingMarket), addressEncoder.encode(mint)],
+    seeds: [Buffer.from(RESERVE_LIQ_SUPPLY_SEED), addressEncoder.encode(reserve)],
     programAddress: programId,
   });
 }
@@ -130,12 +129,11 @@ export async function reserveLiqSupplyPda(
  * @returns [vaultPda, bump]
  */
 export async function reserveFeeVaultPda(
-  lendingMarket: Address,
-  mint: Address,
+  reserve: Address,
   programId: Address = PROGRAM_ID
 ): Promise<ProgramDerivedAddress> {
   return getProgramDerivedAddress({
-    seeds: [Buffer.from(FEE_RECEIVER_SEED), addressEncoder.encode(lendingMarket), addressEncoder.encode(mint)],
+    seeds: [Buffer.from(FEE_RECEIVER_SEED), addressEncoder.encode(reserve)],
     programAddress: programId,
   });
 }
@@ -148,12 +146,11 @@ export async function reserveFeeVaultPda(
  * @returns [mintPda, bump]
  */
 export async function reserveCollateralMintPda(
-  lendingMarket: Address,
-  mint: Address,
+  reserve: Address,
   programId: Address = PROGRAM_ID
 ): Promise<ProgramDerivedAddress> {
   return getProgramDerivedAddress({
-    seeds: [Buffer.from(RESERVE_COLL_MINT_SEED), addressEncoder.encode(lendingMarket), addressEncoder.encode(mint)],
+    seeds: [Buffer.from(RESERVE_COLL_MINT_SEED), addressEncoder.encode(reserve)],
     programAddress: programId,
   });
 }
@@ -166,12 +163,11 @@ export async function reserveCollateralMintPda(
  * @returns [pda, bump]
  */
 export function reserveCollateralSupplyPda(
-  lendingMarket: Address,
-  mint: Address,
+  reserve: Address,
   programId: Address = PROGRAM_ID
 ): Promise<ProgramDerivedAddress> {
   return getProgramDerivedAddress({
-    seeds: [Buffer.from(RESERVE_COLL_SUPPLY_SEED), addressEncoder.encode(lendingMarket), addressEncoder.encode(mint)],
+    seeds: [Buffer.from(RESERVE_COLL_SUPPLY_SEED), addressEncoder.encode(reserve)],
     programAddress: programId,
   });
 }

package/src/utils/vault.ts

@@ -46,6 +46,12 @@ export function decodeVaultState(data: Buffer): VaultState {
     vaultFarm: dec.vaultFarm,
     creationTimestamp: dec.creationTimestamp,
     allocationAdmin: dec.allocationAdmin,
+    withdrawalPenaltyLamports: dec.withdrawalPenaltyLamports,
+    withdrawalPenaltyBps: dec.withdrawalPenaltyBps,
     padding3: dec.padding3,
+    firstLossCapitalFarm: dec.firstLossCapitalFarm,
+    allowAllocationsInWhitelistedReservesOnly: dec.allowAllocationsInWhitelistedReservesOnly,
+    allowInvestInWhitelistedReservesOnly: dec.allowInvestInWhitelistedReservesOnly,
+    padding4: dec.padding4,
   });
 }