@kamino-finance/klend-sdk 7.2.6 → 7.3.1

package/src/@codegen/kvault/types/ReserveFees.ts

@@ -11,9 +11,9 @@ export interface ReserveFeesFields {
    * clarity:
    * 1% = (1 << 60) / 100 = 11529215046068470
    * 0.01% (1 basis point) = 115292150460685
-   * 0.00001% (Aave borrow fee) = 115292150461
+   * 0.00001% (Aave origination fee) = 115292150461
    */
-  borrowFeeSf: BN
+  originationFeeSf: BN
   /**
    * Fee for flash loan, expressed as scaled fraction.
    * 0.3% (Aave flash loan fee) = 0.003 * 2^60 = 3458764513820541
@@ -30,9 +30,9 @@ export interface ReserveFeesJSON {
    * clarity:
    * 1% = (1 << 60) / 100 = 11529215046068470
    * 0.01% (1 basis point) = 115292150460685
-   * 0.00001% (Aave borrow fee) = 115292150461
+   * 0.00001% (Aave origination fee) = 115292150461
    */
-  borrowFeeSf: string
+  originationFeeSf: string
   /**
    * Fee for flash loan, expressed as scaled fraction.
    * 0.3% (Aave flash loan fee) = 0.003 * 2^60 = 3458764513820541
@@ -56,9 +56,9 @@ export class ReserveFees {
    * clarity:
    * 1% = (1 << 60) / 100 = 11529215046068470
    * 0.01% (1 basis point) = 115292150460685
-   * 0.00001% (Aave borrow fee) = 115292150461
+   * 0.00001% (Aave origination fee) = 115292150461
    */
-  readonly borrowFeeSf: BN
+  readonly originationFeeSf: BN
   /**
    * Fee for flash loan, expressed as scaled fraction.
    * 0.3% (Aave flash loan fee) = 0.003 * 2^60 = 3458764513820541
@@ -68,7 +68,7 @@ export class ReserveFees {
   readonly padding: Array<number>
 
   constructor(fields: ReserveFeesFields) {
-    this.borrowFeeSf = fields.borrowFeeSf
+    this.originationFeeSf = fields.originationFeeSf
     this.flashLoanFeeSf = fields.flashLoanFeeSf
     this.padding = fields.padding
   }
@@ -76,7 +76,7 @@ export class ReserveFees {
   static layout(property?: string) {
     return borsh.struct(
       [
-        borsh.u64("borrowFeeSf"),
+        borsh.u64("originationFeeSf"),
         borsh.u64("flashLoanFeeSf"),
         borsh.array(borsh.u8(), 8, "padding"),
       ],
@@ -87,7 +87,7 @@ export class ReserveFees {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static fromDecoded(obj: any) {
     return new ReserveFees({
-      borrowFeeSf: obj.borrowFeeSf,
+      originationFeeSf: obj.originationFeeSf,
       flashLoanFeeSf: obj.flashLoanFeeSf,
       padding: obj.padding,
     })
@@ -95,7 +95,7 @@ export class ReserveFees {
 
   static toEncodable(fields: ReserveFeesFields) {
     return {
-      borrowFeeSf: fields.borrowFeeSf,
+      originationFeeSf: fields.originationFeeSf,
       flashLoanFeeSf: fields.flashLoanFeeSf,
       padding: fields.padding,
     }
@@ -103,7 +103,7 @@ export class ReserveFees {
 
   toJSON(): ReserveFeesJSON {
     return {
-      borrowFeeSf: this.borrowFeeSf.toString(),
+      originationFeeSf: this.originationFeeSf.toString(),
       flashLoanFeeSf: this.flashLoanFeeSf.toString(),
       padding: this.padding,
     }
@@ -111,7 +111,7 @@ export class ReserveFees {
 
   static fromJSON(obj: ReserveFeesJSON): ReserveFees {
     return new ReserveFees({
-      borrowFeeSf: new BN(obj.borrowFeeSf),
+      originationFeeSf: new BN(obj.originationFeeSf),
       flashLoanFeeSf: new BN(obj.flashLoanFeeSf),
       padding: obj.padding,
     })

package/src/@codegen/kvault/types/UpdateGlobalConfigMode.ts

@@ -0,0 +1,160 @@
+import { address, Address } from "@solana/kit" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+import { borshAddress } from "../utils"
+
+export type PendingAdminFields = [Address]
+export type PendingAdminValue = [Address]
+
+export interface PendingAdminJSON {
+  kind: "PendingAdmin"
+  value: [string]
+}
+
+export class PendingAdmin {
+  static readonly discriminator = 0
+  static readonly kind = "PendingAdmin"
+  readonly discriminator = 0
+  readonly kind = "PendingAdmin"
+  readonly value: PendingAdminValue
+
+  constructor(value: PendingAdminFields) {
+    this.value = [value[0]]
+  }
+
+  toJSON(): PendingAdminJSON {
+    return {
+      kind: "PendingAdmin",
+      value: [this.value[0]],
+    }
+  }
+
+  toEncodable() {
+    return {
+      PendingAdmin: {
+        _0: this.value[0],
+      },
+    }
+  }
+}
+
+export type MinWithdrawalPenaltyLamportsFields = [BN]
+export type MinWithdrawalPenaltyLamportsValue = [BN]
+
+export interface MinWithdrawalPenaltyLamportsJSON {
+  kind: "MinWithdrawalPenaltyLamports"
+  value: [string]
+}
+
+export class MinWithdrawalPenaltyLamports {
+  static readonly discriminator = 1
+  static readonly kind = "MinWithdrawalPenaltyLamports"
+  readonly discriminator = 1
+  readonly kind = "MinWithdrawalPenaltyLamports"
+  readonly value: MinWithdrawalPenaltyLamportsValue
+
+  constructor(value: MinWithdrawalPenaltyLamportsFields) {
+    this.value = [value[0]]
+  }
+
+  toJSON(): MinWithdrawalPenaltyLamportsJSON {
+    return {
+      kind: "MinWithdrawalPenaltyLamports",
+      value: [this.value[0].toString()],
+    }
+  }
+
+  toEncodable() {
+    return {
+      MinWithdrawalPenaltyLamports: {
+        _0: this.value[0],
+      },
+    }
+  }
+}
+
+export type MinWithdrawalPenaltyBPSFields = [BN]
+export type MinWithdrawalPenaltyBPSValue = [BN]
+
+export interface MinWithdrawalPenaltyBPSJSON {
+  kind: "MinWithdrawalPenaltyBPS"
+  value: [string]
+}
+
+export class MinWithdrawalPenaltyBPS {
+  static readonly discriminator = 2
+  static readonly kind = "MinWithdrawalPenaltyBPS"
+  readonly discriminator = 2
+  readonly kind = "MinWithdrawalPenaltyBPS"
+  readonly value: MinWithdrawalPenaltyBPSValue
+
+  constructor(value: MinWithdrawalPenaltyBPSFields) {
+    this.value = [value[0]]
+  }
+
+  toJSON(): MinWithdrawalPenaltyBPSJSON {
+    return {
+      kind: "MinWithdrawalPenaltyBPS",
+      value: [this.value[0].toString()],
+    }
+  }
+
+  toEncodable() {
+    return {
+      MinWithdrawalPenaltyBPS: {
+        _0: this.value[0],
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.UpdateGlobalConfigModeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("PendingAdmin" in obj) {
+    const val = obj["PendingAdmin"]
+    return new PendingAdmin([val["_0"]])
+  }
+  if ("MinWithdrawalPenaltyLamports" in obj) {
+    const val = obj["MinWithdrawalPenaltyLamports"]
+    return new MinWithdrawalPenaltyLamports([val["_0"]])
+  }
+  if ("MinWithdrawalPenaltyBPS" in obj) {
+    const val = obj["MinWithdrawalPenaltyBPS"]
+    return new MinWithdrawalPenaltyBPS([val["_0"]])
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.UpdateGlobalConfigModeJSON
+): types.UpdateGlobalConfigModeKind {
+  switch (obj.kind) {
+    case "PendingAdmin": {
+      return new PendingAdmin([address(obj.value[0])])
+    }
+    case "MinWithdrawalPenaltyLamports": {
+      return new MinWithdrawalPenaltyLamports([new BN(obj.value[0])])
+    }
+    case "MinWithdrawalPenaltyBPS": {
+      return new MinWithdrawalPenaltyBPS([new BN(obj.value[0])])
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([borshAddress("_0")], "PendingAdmin"),
+    borsh.struct([borsh.u64("_0")], "MinWithdrawalPenaltyLamports"),
+    borsh.struct([borsh.u64("_0")], "MinWithdrawalPenaltyBPS"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/@codegen/kvault/types/UpdateReserveWhitelistMode.ts

@@ -0,0 +1,117 @@
+import { address, Address } from "@solana/kit" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+import { borshAddress } from "../utils"
+
+export type InvestFields = [number]
+export type InvestValue = [number]
+
+export interface InvestJSON {
+  kind: "Invest"
+  value: [number]
+}
+
+export class Invest {
+  static readonly discriminator = 0
+  static readonly kind = "Invest"
+  readonly discriminator = 0
+  readonly kind = "Invest"
+  readonly value: InvestValue
+
+  constructor(value: InvestFields) {
+    this.value = [value[0]]
+  }
+
+  toJSON(): InvestJSON {
+    return {
+      kind: "Invest",
+      value: [this.value[0]],
+    }
+  }
+
+  toEncodable() {
+    return {
+      Invest: {
+        _0: this.value[0],
+      },
+    }
+  }
+}
+
+export type AddAllocationFields = [number]
+export type AddAllocationValue = [number]
+
+export interface AddAllocationJSON {
+  kind: "AddAllocation"
+  value: [number]
+}
+
+export class AddAllocation {
+  static readonly discriminator = 1
+  static readonly kind = "AddAllocation"
+  readonly discriminator = 1
+  readonly kind = "AddAllocation"
+  readonly value: AddAllocationValue
+
+  constructor(value: AddAllocationFields) {
+    this.value = [value[0]]
+  }
+
+  toJSON(): AddAllocationJSON {
+    return {
+      kind: "AddAllocation",
+      value: [this.value[0]],
+    }
+  }
+
+  toEncodable() {
+    return {
+      AddAllocation: {
+        _0: this.value[0],
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.UpdateReserveWhitelistModeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Invest" in obj) {
+    const val = obj["Invest"]
+    return new Invest([val["_0"]])
+  }
+  if ("AddAllocation" in obj) {
+    const val = obj["AddAllocation"]
+    return new AddAllocation([val["_0"]])
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.UpdateReserveWhitelistModeJSON
+): types.UpdateReserveWhitelistModeKind {
+  switch (obj.kind) {
+    case "Invest": {
+      return new Invest([obj.value[0]])
+    }
+    case "AddAllocation": {
+      return new AddAllocation([obj.value[0]])
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([borsh.u8("_0")], "Invest"),
+    borsh.struct([borsh.u8("_0")], "AddAllocation"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/@codegen/kvault/types/VaultConfigField.ts

@@ -326,6 +326,121 @@ export class UnallocatedTokensCap {
   }
 }
 
+export interface WithdrawalPenaltyLamportsJSON {
+  kind: "WithdrawalPenaltyLamports"
+}
+
+export class WithdrawalPenaltyLamports {
+  static readonly discriminator = 14
+  static readonly kind = "WithdrawalPenaltyLamports"
+  readonly discriminator = 14
+  readonly kind = "WithdrawalPenaltyLamports"
+
+  toJSON(): WithdrawalPenaltyLamportsJSON {
+    return {
+      kind: "WithdrawalPenaltyLamports",
+    }
+  }
+
+  toEncodable() {
+    return {
+      WithdrawalPenaltyLamports: {},
+    }
+  }
+}
+
+export interface WithdrawalPenaltyBpsJSON {
+  kind: "WithdrawalPenaltyBps"
+}
+
+export class WithdrawalPenaltyBps {
+  static readonly discriminator = 15
+  static readonly kind = "WithdrawalPenaltyBps"
+  readonly discriminator = 15
+  readonly kind = "WithdrawalPenaltyBps"
+
+  toJSON(): WithdrawalPenaltyBpsJSON {
+    return {
+      kind: "WithdrawalPenaltyBps",
+    }
+  }
+
+  toEncodable() {
+    return {
+      WithdrawalPenaltyBps: {},
+    }
+  }
+}
+
+export interface FirstLossCapitalFarmJSON {
+  kind: "FirstLossCapitalFarm"
+}
+
+export class FirstLossCapitalFarm {
+  static readonly discriminator = 16
+  static readonly kind = "FirstLossCapitalFarm"
+  readonly discriminator = 16
+  readonly kind = "FirstLossCapitalFarm"
+
+  toJSON(): FirstLossCapitalFarmJSON {
+    return {
+      kind: "FirstLossCapitalFarm",
+    }
+  }
+
+  toEncodable() {
+    return {
+      FirstLossCapitalFarm: {},
+    }
+  }
+}
+
+export interface AllowAllocationsInWhitelistedReservesOnlyJSON {
+  kind: "AllowAllocationsInWhitelistedReservesOnly"
+}
+
+export class AllowAllocationsInWhitelistedReservesOnly {
+  static readonly discriminator = 17
+  static readonly kind = "AllowAllocationsInWhitelistedReservesOnly"
+  readonly discriminator = 17
+  readonly kind = "AllowAllocationsInWhitelistedReservesOnly"
+
+  toJSON(): AllowAllocationsInWhitelistedReservesOnlyJSON {
+    return {
+      kind: "AllowAllocationsInWhitelistedReservesOnly",
+    }
+  }
+
+  toEncodable() {
+    return {
+      AllowAllocationsInWhitelistedReservesOnly: {},
+    }
+  }
+}
+
+export interface AllowInvestInWhitelistedReservesOnlyJSON {
+  kind: "AllowInvestInWhitelistedReservesOnly"
+}
+
+export class AllowInvestInWhitelistedReservesOnly {
+  static readonly discriminator = 18
+  static readonly kind = "AllowInvestInWhitelistedReservesOnly"
+  readonly discriminator = 18
+  readonly kind = "AllowInvestInWhitelistedReservesOnly"
+
+  toJSON(): AllowInvestInWhitelistedReservesOnlyJSON {
+    return {
+      kind: "AllowInvestInWhitelistedReservesOnly",
+    }
+  }
+
+  toEncodable() {
+    return {
+      AllowInvestInWhitelistedReservesOnly: {},
+    }
+  }
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function fromDecoded(obj: any): types.VaultConfigFieldKind {
   if (typeof obj !== "object") {
@@ -374,6 +489,21 @@ export function fromDecoded(obj: any): types.VaultConfigFieldKind {
   if ("UnallocatedTokensCap" in obj) {
     return new UnallocatedTokensCap()
   }
+  if ("WithdrawalPenaltyLamports" in obj) {
+    return new WithdrawalPenaltyLamports()
+  }
+  if ("WithdrawalPenaltyBps" in obj) {
+    return new WithdrawalPenaltyBps()
+  }
+  if ("FirstLossCapitalFarm" in obj) {
+    return new FirstLossCapitalFarm()
+  }
+  if ("AllowAllocationsInWhitelistedReservesOnly" in obj) {
+    return new AllowAllocationsInWhitelistedReservesOnly()
+  }
+  if ("AllowInvestInWhitelistedReservesOnly" in obj) {
+    return new AllowInvestInWhitelistedReservesOnly()
+  }
 
   throw new Error("Invalid enum object")
 }
@@ -424,6 +554,21 @@ export function fromJSON(
     case "UnallocatedTokensCap": {
       return new UnallocatedTokensCap()
     }
+    case "WithdrawalPenaltyLamports": {
+      return new WithdrawalPenaltyLamports()
+    }
+    case "WithdrawalPenaltyBps": {
+      return new WithdrawalPenaltyBps()
+    }
+    case "FirstLossCapitalFarm": {
+      return new FirstLossCapitalFarm()
+    }
+    case "AllowAllocationsInWhitelistedReservesOnly": {
+      return new AllowAllocationsInWhitelistedReservesOnly()
+    }
+    case "AllowInvestInWhitelistedReservesOnly": {
+      return new AllowInvestInWhitelistedReservesOnly()
+    }
   }
 }
 
@@ -443,6 +588,11 @@ export function layout(property?: string) {
     borsh.struct([], "AllocationAdmin"),
     borsh.struct([], "UnallocatedWeight"),
     borsh.struct([], "UnallocatedTokensCap"),
+    borsh.struct([], "WithdrawalPenaltyLamports"),
+    borsh.struct([], "WithdrawalPenaltyBps"),
+    borsh.struct([], "FirstLossCapitalFarm"),
+    borsh.struct([], "AllowAllocationsInWhitelistedReservesOnly"),
+    borsh.struct([], "AllowInvestInWhitelistedReservesOnly"),
   ])
   if (property !== undefined) {
     return ret.replicate(property)

package/src/@codegen/kvault/types/index.ts

@@ -1,4 +1,6 @@
+import * as UpdateReserveWhitelistMode from "./UpdateReserveWhitelistMode"
 import * as VaultConfigField from "./VaultConfigField"
+import * as UpdateGlobalConfigMode from "./UpdateGlobalConfigMode"
 
 export { LastUpdate } from "./LastUpdate"
 export type { LastUpdateFields, LastUpdateJSON } from "./LastUpdate"
@@ -49,6 +51,15 @@ export type {
 } from "./BorrowRateCurve"
 export { CurvePoint } from "./CurvePoint"
 export type { CurvePointFields, CurvePointJSON } from "./CurvePoint"
+export { UpdateReserveWhitelistMode }
+
+export type UpdateReserveWhitelistModeKind =
+  | UpdateReserveWhitelistMode.Invest
+  | UpdateReserveWhitelistMode.AddAllocation
+export type UpdateReserveWhitelistModeJSON =
+  | UpdateReserveWhitelistMode.InvestJSON
+  | UpdateReserveWhitelistMode.AddAllocationJSON
+
 export { VaultConfigField }
 
 export type VaultConfigFieldKind =
@@ -66,6 +77,11 @@ export type VaultConfigFieldKind =
   | VaultConfigField.AllocationAdmin
   | VaultConfigField.UnallocatedWeight
   | VaultConfigField.UnallocatedTokensCap
+  | VaultConfigField.WithdrawalPenaltyLamports
+  | VaultConfigField.WithdrawalPenaltyBps
+  | VaultConfigField.FirstLossCapitalFarm
+  | VaultConfigField.AllowAllocationsInWhitelistedReservesOnly
+  | VaultConfigField.AllowInvestInWhitelistedReservesOnly
 export type VaultConfigFieldJSON =
   | VaultConfigField.PerformanceFeeBpsJSON
   | VaultConfigField.ManagementFeeBpsJSON
@@ -81,9 +97,24 @@ export type VaultConfigFieldJSON =
   | VaultConfigField.AllocationAdminJSON
   | VaultConfigField.UnallocatedWeightJSON
   | VaultConfigField.UnallocatedTokensCapJSON
+  | VaultConfigField.WithdrawalPenaltyLamportsJSON
+  | VaultConfigField.WithdrawalPenaltyBpsJSON
+  | VaultConfigField.FirstLossCapitalFarmJSON
+  | VaultConfigField.AllowAllocationsInWhitelistedReservesOnlyJSON
+  | VaultConfigField.AllowInvestInWhitelistedReservesOnlyJSON
 
 export { VaultAllocation } from "./VaultAllocation"
 export type {
   VaultAllocationFields,
   VaultAllocationJSON,
 } from "./VaultAllocation"
+export { UpdateGlobalConfigMode }
+
+export type UpdateGlobalConfigModeKind =
+  | UpdateGlobalConfigMode.PendingAdmin
+  | UpdateGlobalConfigMode.MinWithdrawalPenaltyLamports
+  | UpdateGlobalConfigMode.MinWithdrawalPenaltyBPS
+export type UpdateGlobalConfigModeJSON =
+  | UpdateGlobalConfigMode.PendingAdminJSON
+  | UpdateGlobalConfigMode.MinWithdrawalPenaltyLamportsJSON
+  | UpdateGlobalConfigMode.MinWithdrawalPenaltyBPSJSON

package/src/classes/manager.ts

@@ -76,7 +76,7 @@ import { ReserveConfig, UpdateLendingMarketMode, UpdateLendingMarketModeKind } f
 import Decimal from 'decimal.js';
 import { VaultState } from '../@codegen/kvault/accounts';
 import { getProgramAccounts } from '../utils/rpc';
-import { VaultConfigField, VaultConfigFieldKind } from '../@codegen/kvault/types';
+import { UpdateReserveWhitelistModeKind, VaultConfigField, VaultConfigFieldKind } from '../@codegen/kvault/types';
 import {
   AcceptVaultOwnershipIxs,
   APYs,
@@ -228,6 +228,15 @@ export class KaminoManager {
     return { reserve: reserveAccount, txnIxs };
   }
 
+  /**
+   * This method initializes the kvault global config (one off, needs to be signed by program owner)
+   * @param admin - the admin of the kvault program
+   * @returns - an instruction to initialize the kvault global config
+   */
+  async initKvaultGlobalConfigIx(admin: TransactionSigner) {
+    return this._vaultClient.initKvaultGlobalConfigIx(admin);
+  }
+
   /**
    * This method will create a vault with a given config. The config can be changed later on, but it is recommended to set it up correctly from the start
    * @param vaultConfig - the config object used to create a vault
@@ -576,6 +585,16 @@ export class KaminoManager {
     return this._vaultClient.depositIxs(user, vault, tokenAmount, vaultReservesMap, farmState);
   }
 
+  async buyVaultSharesIxs(
+    user: TransactionSigner,
+    vault: KaminoVault,
+    tokenAmount: Decimal,
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    farmState?: FarmState
+  ): Promise<DepositIxs> {
+    return this._vaultClient.buySharesIxs(user, vault, tokenAmount, vaultReservesMap, farmState);
+  }
+
   /**
    * This function creates instructions to stake the shares in the vault farm if the vault has a farm
    * @param user - user to stake
@@ -619,6 +638,23 @@ export class KaminoManager {
     return this._vaultClient.updateVaultConfigIxs(vault, mode, value, signer, lutIxsSigner, skipLutUpdate);
   }
 
+  /**
+   * Add or update a reserve whitelist entry. This controls whether the reserve is whitelisted for adding/updating
+   * allocations or for invest, depending on the mode parameter.
+   *
+   * @param reserve - Address of the reserve to whitelist
+   * @param mode - The whitelist mode: either 'Invest' or 'AddAllocation' with a value (1 = add, 0 = remove)
+   * @param globalAdmin - The global admin that signs the transaction
+   * @returns - An instruction to add/update the whitelisted reserve entry
+   */
+  async addUpdateWhitelistedReserveIx(
+    reserve: Address,
+    mode: UpdateReserveWhitelistModeKind,
+    globalAdmin: TransactionSigner
+  ): Promise<Instruction> {
+    return this._vaultClient.addUpdateWhitelistedReserveIx(reserve, mode, globalAdmin);
+  }
+
   /** Sets the farm where the shares can be staked. This is store in vault state and a vault can only have one farm, so the new farm will ovveride the old farm
    * @param vault - vault to set the farm for
    * @param farm - the farm where the vault shares can be staked
@@ -692,6 +728,17 @@ export class KaminoManager {
     return this._vaultClient.withdrawIxs(user, vault, shareAmount, slot, vaultReservesMap, farmState);
   }
 
+  async sellVaultSharesIxs(
+    user: TransactionSigner,
+    vault: KaminoVault,
+    shareAmount: Decimal,
+    slot: Slot,
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    farmState?: FarmState
+  ): Promise<WithdrawIxs> {
+    return this._vaultClient.sellSharesIxs(user, vault, shareAmount, slot, vaultReservesMap, farmState);
+  }
+
   /**
    * This method withdraws all the pending fees from the vault to the owner's token ATA
    * @param vault - vault for which the admin withdraws the pending fees
@@ -1706,6 +1753,8 @@ export const MARKET_UPDATER = new ConfigUpdater(UpdateLendingMarketMode.fromDeco
   [UpdateLendingMarketMode.UpdateInitialDepositAmount.kind]: config.minInitialDepositAmount,
   [UpdateLendingMarketMode.UpdateObligationOrderCreationEnabled.kind]: config.obligationOrderCreationEnabled,
   [UpdateLendingMarketMode.UpdateObligationOrderExecutionEnabled.kind]: config.obligationOrderExecutionEnabled,
+  [UpdateLendingMarketMode.UpdateProposerAuthority.kind]: config.proposerAuthority,
+  [UpdateLendingMarketMode.UpdatePriceTriggeredLiquidationDisabled.kind]: config.priceTriggeredLiquidationDisabled,
 }));
 
 function parseForChangesMarketConfigAndGetIxs(