@kamino-finance/klend-sdk 7.4.0-beta.1 → 7.4.0-beta.2

package/src/@codegen/kvault/accounts/VaultState.ts

@@ -56,7 +56,21 @@ export interface VaultStateFields {
   firstLossCapitalFarm: Address
   allowAllocationsInWhitelistedReservesOnly: number
   allowInvestInWhitelistedReservesOnly: number
-  padding4: Array<number>
+  padding2: Array<number>
+  /**
+   * The amount of native SOL (in lamports) held by the [Self::base_vault_authority] for Klend's
+   * withdraw ticket(s) rent purposes.
+   *
+   * Context: in order to disinvest from a 100%-utilized reserve, we need to enter the reserve's
+   * withdraw queue. Klend needs to issue a ticket, and wants to cover its rent from the owner's
+   * (i.e. vault authority's) account. If the budget is 0, we have to transfer a single ticket's
+   * rent from the transaction executor (i.e. Kvault's bot). Each ticket's rent is refunded when
+   * the ticket is closed, so typically this budget should be available - in fact, the total sum
+   * transferred from the executor here will be equal to the rent for a maximum number of
+   * tickets that have ever been simultaneously in-flight.
+   */
+  withdrawTicketRentBudget: BN
+  padding4: BN
   padding3: Array<BN>
 }
 
@@ -101,7 +115,21 @@ export interface VaultStateJSON {
   firstLossCapitalFarm: string
   allowAllocationsInWhitelistedReservesOnly: number
   allowInvestInWhitelistedReservesOnly: number
-  padding4: Array<number>
+  padding2: Array<number>
+  /**
+   * The amount of native SOL (in lamports) held by the [Self::base_vault_authority] for Klend's
+   * withdraw ticket(s) rent purposes.
+   *
+   * Context: in order to disinvest from a 100%-utilized reserve, we need to enter the reserve's
+   * withdraw queue. Klend needs to issue a ticket, and wants to cover its rent from the owner's
+   * (i.e. vault authority's) account. If the budget is 0, we have to transfer a single ticket's
+   * rent from the transaction executor (i.e. Kvault's bot). Each ticket's rent is refunded when
+   * the ticket is closed, so typically this budget should be available - in fact, the total sum
+   * transferred from the executor here will be equal to the rent for a maximum number of
+   * tickets that have ever been simultaneously in-flight.
+   */
+  withdrawTicketRentBudget: string
+  padding4: string
   padding3: Array<string>
 }
 
@@ -146,7 +174,21 @@ export class VaultState {
   readonly firstLossCapitalFarm: Address
   readonly allowAllocationsInWhitelistedReservesOnly: number
   readonly allowInvestInWhitelistedReservesOnly: number
-  readonly padding4: Array<number>
+  readonly padding2: Array<number>
+  /**
+   * The amount of native SOL (in lamports) held by the [Self::base_vault_authority] for Klend's
+   * withdraw ticket(s) rent purposes.
+   *
+   * Context: in order to disinvest from a 100%-utilized reserve, we need to enter the reserve's
+   * withdraw queue. Klend needs to issue a ticket, and wants to cover its rent from the owner's
+   * (i.e. vault authority's) account. If the budget is 0, we have to transfer a single ticket's
+   * rent from the transaction executor (i.e. Kvault's bot). Each ticket's rent is refunded when
+   * the ticket is closed, so typically this budget should be available - in fact, the total sum
+   * transferred from the executor here will be equal to the rent for a maximum number of
+   * tickets that have ever been simultaneously in-flight.
+   */
+  readonly withdrawTicketRentBudget: BN
+  readonly padding4: BN
   readonly padding3: Array<BN>
 
   static readonly discriminator = Buffer.from([
@@ -194,8 +236,10 @@ export class VaultState {
     borshAddress("firstLossCapitalFarm"),
     borsh.u8("allowAllocationsInWhitelistedReservesOnly"),
     borsh.u8("allowInvestInWhitelistedReservesOnly"),
-    borsh.array(borsh.u8(), 14, "padding4"),
-    borsh.array(borsh.u128(), 238, "padding3"),
+    borsh.array(borsh.u8(), 14, "padding2"),
+    borsh.u64("withdrawTicketRentBudget"),
+    borsh.u64("padding4"),
+    borsh.array(borsh.u128(), 237, "padding3"),
   ])
 
   constructor(fields: VaultStateFields) {
@@ -243,6 +287,8 @@ export class VaultState {
       fields.allowAllocationsInWhitelistedReservesOnly
     this.allowInvestInWhitelistedReservesOnly =
       fields.allowInvestInWhitelistedReservesOnly
+    this.padding2 = fields.padding2
+    this.withdrawTicketRentBudget = fields.withdrawTicketRentBudget
     this.padding4 = fields.padding4
     this.padding3 = fields.padding3
   }
@@ -341,6 +387,8 @@ export class VaultState {
         dec.allowAllocationsInWhitelistedReservesOnly,
       allowInvestInWhitelistedReservesOnly:
         dec.allowInvestInWhitelistedReservesOnly,
+      padding2: dec.padding2,
+      withdrawTicketRentBudget: dec.withdrawTicketRentBudget,
       padding4: dec.padding4,
       padding3: dec.padding3,
     })
@@ -392,7 +440,9 @@ export class VaultState {
         this.allowAllocationsInWhitelistedReservesOnly,
       allowInvestInWhitelistedReservesOnly:
         this.allowInvestInWhitelistedReservesOnly,
-      padding4: this.padding4,
+      padding2: this.padding2,
+      withdrawTicketRentBudget: this.withdrawTicketRentBudget.toString(),
+      padding4: this.padding4.toString(),
       padding3: this.padding3.map((item) => item.toString()),
     }
   }
@@ -443,7 +493,9 @@ export class VaultState {
         obj.allowAllocationsInWhitelistedReservesOnly,
       allowInvestInWhitelistedReservesOnly:
         obj.allowInvestInWhitelistedReservesOnly,
-      padding4: obj.padding4,
+      padding2: obj.padding2,
+      withdrawTicketRentBudget: new BN(obj.withdrawTicketRentBudget),
+      padding4: new BN(obj.padding4),
       padding3: obj.padding3.map((item) => new BN(item)),
     })
   }

package/src/@codegen/kvault/accounts/WithdrawTicket.ts

@@ -0,0 +1,280 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  address,
+  Address,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  GetAccountInfoApi,
+  GetMultipleAccountsApi,
+  Rpc,
+} from "@solana/kit"
+/* eslint-enable @typescript-eslint/no-unused-vars */
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { borshAddress } from "../utils" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface WithdrawTicketFields {
+  /** This ticket's place in the queue; the same as used for PDA derivation. */
+  sequenceNumber: BN
+  /** The funds' owner (the user who called the `enqueue_to_withdraw` handler). */
+  owner: Address
+  /** The reserve to withdraw from. */
+  reserve: Address
+  /**
+   * The token account to which the finally-available liquidity should be transferred (by the
+   * `withdraw_queued_liquidity` handler).
+   */
+  userDestinationLiquidityTa: Address
+  /** The amount of collateral still waiting to be withdrawn using this ticket. */
+  queuedCollateralAmount: BN
+  /**
+   * The timestamp at which the queue was entered.
+   *
+   * This is currently only a piece of metadata, not used by the logic.
+   */
+  createdAtTimestamp: BN
+  /**
+   * Whether the ticket has been found to be invalid (e.g. the [Self::user_destination_liquidity]
+   * has been repurposed) by the `withdraw_queued_liquidity` handler.
+   * To be specific: valid = `0`, invalid = `1`.
+   *
+   * An invalid ticket cannot be made valid again, and can only be passed to the
+   * `recover_invalid_ticket_collateral` handler.
+   */
+  invalid: number
+  /** One of the valid [ProgressCallbackType] representations. */
+  progressCallbackType: number
+  /** Inner padding, for alignment. */
+  alignmentPadding: Array<number>
+  /** The (optional) accounts to be used by [Self::progress_callback_type]s. */
+  progressCallbackCustomAccounts: Array<Address>
+  /** Trailing padding, for future developments. */
+  endPadding: Array<BN>
+}
+
+export interface WithdrawTicketJSON {
+  /** This ticket's place in the queue; the same as used for PDA derivation. */
+  sequenceNumber: string
+  /** The funds' owner (the user who called the `enqueue_to_withdraw` handler). */
+  owner: string
+  /** The reserve to withdraw from. */
+  reserve: string
+  /**
+   * The token account to which the finally-available liquidity should be transferred (by the
+   * `withdraw_queued_liquidity` handler).
+   */
+  userDestinationLiquidityTa: string
+  /** The amount of collateral still waiting to be withdrawn using this ticket. */
+  queuedCollateralAmount: string
+  /**
+   * The timestamp at which the queue was entered.
+   *
+   * This is currently only a piece of metadata, not used by the logic.
+   */
+  createdAtTimestamp: string
+  /**
+   * Whether the ticket has been found to be invalid (e.g. the [Self::user_destination_liquidity]
+   * has been repurposed) by the `withdraw_queued_liquidity` handler.
+   * To be specific: valid = `0`, invalid = `1`.
+   *
+   * An invalid ticket cannot be made valid again, and can only be passed to the
+   * `recover_invalid_ticket_collateral` handler.
+   */
+  invalid: number
+  /** One of the valid [ProgressCallbackType] representations. */
+  progressCallbackType: number
+  /** Inner padding, for alignment. */
+  alignmentPadding: Array<number>
+  /** The (optional) accounts to be used by [Self::progress_callback_type]s. */
+  progressCallbackCustomAccounts: Array<string>
+  /** Trailing padding, for future developments. */
+  endPadding: Array<string>
+}
+
+/**
+ * A finite-lifecycle account representing a specific depositor's place in the withdraw queue of
+ * a specific reserve.
+ *
+ * The lifecycle:
+ * 1. The depositor holding ctokens wants to withdraw funds from the reserve, and finds out that
+ * the required amount is not available (due to high utilization).
+ * 2. The depositor calls the `enqueue_to_withdraw` handler.
+ * 3. The handler transfers the depositor's ctokens to the reserve's internal "pending" vault.
+ * 4. The handler initializes a new [WithdrawTicket] account, with the next available sequence
+ * number.
+ * 5. The depositor waits until his ticket is the next expected one for actual withdraw, and until
+ * the reserve has enough liquidity.
+ * 6. Anyone (the depositor or a bot) calls the permissionless `withdraw_queued_liquidity`
+ * handler. If the ticket became invalid (e.g. destination account no longer exists), then the
+ * depositor can call the `recover_invalid_ticket_collateral` handler instead.
+ * 7. The handler transfers the liquidity amount according to the current exchange rate.
+ * 8. The handler closes the ticket account.
+ */
+export class WithdrawTicket {
+  /** This ticket's place in the queue; the same as used for PDA derivation. */
+  readonly sequenceNumber: BN
+  /** The funds' owner (the user who called the `enqueue_to_withdraw` handler). */
+  readonly owner: Address
+  /** The reserve to withdraw from. */
+  readonly reserve: Address
+  /**
+   * The token account to which the finally-available liquidity should be transferred (by the
+   * `withdraw_queued_liquidity` handler).
+   */
+  readonly userDestinationLiquidityTa: Address
+  /** The amount of collateral still waiting to be withdrawn using this ticket. */
+  readonly queuedCollateralAmount: BN
+  /**
+   * The timestamp at which the queue was entered.
+   *
+   * This is currently only a piece of metadata, not used by the logic.
+   */
+  readonly createdAtTimestamp: BN
+  /**
+   * Whether the ticket has been found to be invalid (e.g. the [Self::user_destination_liquidity]
+   * has been repurposed) by the `withdraw_queued_liquidity` handler.
+   * To be specific: valid = `0`, invalid = `1`.
+   *
+   * An invalid ticket cannot be made valid again, and can only be passed to the
+   * `recover_invalid_ticket_collateral` handler.
+   */
+  readonly invalid: number
+  /** One of the valid [ProgressCallbackType] representations. */
+  readonly progressCallbackType: number
+  /** Inner padding, for alignment. */
+  readonly alignmentPadding: Array<number>
+  /** The (optional) accounts to be used by [Self::progress_callback_type]s. */
+  readonly progressCallbackCustomAccounts: Array<Address>
+  /** Trailing padding, for future developments. */
+  readonly endPadding: Array<BN>
+
+  static readonly discriminator = Buffer.from([
+    237, 23, 164, 58, 53, 248, 240, 94,
+  ])
+
+  static readonly layout = borsh.struct<WithdrawTicket>([
+    borsh.u64("sequenceNumber"),
+    borshAddress("owner"),
+    borshAddress("reserve"),
+    borshAddress("userDestinationLiquidityTa"),
+    borsh.u64("queuedCollateralAmount"),
+    borsh.u64("createdAtTimestamp"),
+    borsh.u8("invalid"),
+    borsh.u8("progressCallbackType"),
+    borsh.array(borsh.u8(), 6, "alignmentPadding"),
+    borsh.array(borshAddress(), 2, "progressCallbackCustomAccounts"),
+    borsh.array(borsh.u64(), 40, "endPadding"),
+  ])
+
+  constructor(fields: WithdrawTicketFields) {
+    this.sequenceNumber = fields.sequenceNumber
+    this.owner = fields.owner
+    this.reserve = fields.reserve
+    this.userDestinationLiquidityTa = fields.userDestinationLiquidityTa
+    this.queuedCollateralAmount = fields.queuedCollateralAmount
+    this.createdAtTimestamp = fields.createdAtTimestamp
+    this.invalid = fields.invalid
+    this.progressCallbackType = fields.progressCallbackType
+    this.alignmentPadding = fields.alignmentPadding
+    this.progressCallbackCustomAccounts = fields.progressCallbackCustomAccounts
+    this.endPadding = fields.endPadding
+  }
+
+  static async fetch(
+    rpc: Rpc<GetAccountInfoApi>,
+    address: Address,
+    programId: Address = PROGRAM_ID
+  ): Promise<WithdrawTicket | null> {
+    const info = await fetchEncodedAccount(rpc, address)
+
+    if (!info.exists) {
+      return null
+    }
+    if (info.programAddress !== programId) {
+      throw new Error(
+        `WithdrawTicketFields account ${address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+      )
+    }
+
+    return this.decode(Buffer.from(info.data))
+  }
+
+  static async fetchMultiple(
+    rpc: Rpc<GetMultipleAccountsApi>,
+    addresses: Address[],
+    programId: Address = PROGRAM_ID
+  ): Promise<Array<WithdrawTicket | null>> {
+    const infos = await fetchEncodedAccounts(rpc, addresses)
+
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null
+      }
+      if (info.programAddress !== programId) {
+        throw new Error(
+          `WithdrawTicketFields account ${info.address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+        )
+      }
+
+      return this.decode(Buffer.from(info.data))
+    })
+  }
+
+  static decode(data: Buffer): WithdrawTicket {
+    if (!data.slice(0, 8).equals(WithdrawTicket.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = WithdrawTicket.layout.decode(data.slice(8))
+
+    return new WithdrawTicket({
+      sequenceNumber: dec.sequenceNumber,
+      owner: dec.owner,
+      reserve: dec.reserve,
+      userDestinationLiquidityTa: dec.userDestinationLiquidityTa,
+      queuedCollateralAmount: dec.queuedCollateralAmount,
+      createdAtTimestamp: dec.createdAtTimestamp,
+      invalid: dec.invalid,
+      progressCallbackType: dec.progressCallbackType,
+      alignmentPadding: dec.alignmentPadding,
+      progressCallbackCustomAccounts: dec.progressCallbackCustomAccounts,
+      endPadding: dec.endPadding,
+    })
+  }
+
+  toJSON(): WithdrawTicketJSON {
+    return {
+      sequenceNumber: this.sequenceNumber.toString(),
+      owner: this.owner,
+      reserve: this.reserve,
+      userDestinationLiquidityTa: this.userDestinationLiquidityTa,
+      queuedCollateralAmount: this.queuedCollateralAmount.toString(),
+      createdAtTimestamp: this.createdAtTimestamp.toString(),
+      invalid: this.invalid,
+      progressCallbackType: this.progressCallbackType,
+      alignmentPadding: this.alignmentPadding,
+      progressCallbackCustomAccounts: this.progressCallbackCustomAccounts,
+      endPadding: this.endPadding.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: WithdrawTicketJSON): WithdrawTicket {
+    return new WithdrawTicket({
+      sequenceNumber: new BN(obj.sequenceNumber),
+      owner: address(obj.owner),
+      reserve: address(obj.reserve),
+      userDestinationLiquidityTa: address(obj.userDestinationLiquidityTa),
+      queuedCollateralAmount: new BN(obj.queuedCollateralAmount),
+      createdAtTimestamp: new BN(obj.createdAtTimestamp),
+      invalid: obj.invalid,
+      progressCallbackType: obj.progressCallbackType,
+      alignmentPadding: obj.alignmentPadding,
+      progressCallbackCustomAccounts: obj.progressCallbackCustomAccounts.map(
+        (item) => address(item)
+      ),
+      endPadding: obj.endPadding.map((item) => new BN(item)),
+    })
+  }
+}

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

@@ -1,5 +1,16 @@
+export { LendingMarket } from "./LendingMarket"
+export type { LendingMarketFields, LendingMarketJSON } from "./LendingMarket"
+export { Obligation } from "./Obligation"
+export type { ObligationFields, ObligationJSON } from "./Obligation"
+export { ReferrerTokenState } from "./ReferrerTokenState"
+export type {
+  ReferrerTokenStateFields,
+  ReferrerTokenStateJSON,
+} from "./ReferrerTokenState"
 export { Reserve } from "./Reserve"
 export type { ReserveFields, ReserveJSON } from "./Reserve"
+export { WithdrawTicket } from "./WithdrawTicket"
+export type { WithdrawTicketFields, WithdrawTicketJSON } from "./WithdrawTicket"
 export { GlobalConfig } from "./GlobalConfig"
 export type { GlobalConfigFields, GlobalConfigJSON } from "./GlobalConfig"
 export { ReserveWhitelistEntry } from "./ReserveWhitelistEntry"

package/src/@codegen/kvault/errors/custom.ts

@@ -55,6 +55,16 @@ export type CustomError =
   | WithdrawalFeeLamportsGreaterThanMaxAllowed
   | ReserveNotWhitelisted
   | InvalidBoolLikeValue
+  | MissingWithdrawQueueAccounts
+  | WithdrawTicketCallbackAccountingMismatch
+  | NotEnoughAvailableLiquidityToInvestIntoVirtual
+  | NotEnoughCTokensToWithdrawFromReserve
+  | ReserveTokenAllocationCapExceeded
+  | AUMDecreasedAfterInvestInVirtualReserve
+  | DestinationReserveIsNotVirtual
+  | AllSourceAccountsMustBeProvided
+  | InvestAndFillVaultStateMismatch
+  | InvestDstAndFillReserveMismatch
 
 export class DepositAmountsZero extends Error {
   static readonly code = 7000
@@ -678,6 +688,128 @@ export class InvalidBoolLikeValue extends Error {
   }
 }
 
+export class MissingWithdrawQueueAccounts extends Error {
+  static readonly code = 7056
+  readonly code = 7056
+  readonly name = "MissingWithdrawQueueAccounts"
+  readonly msg =
+    "Withdraw queue accounts must be present when reserve has not enough freely-available liquidity"
+
+  constructor(readonly logs?: string[]) {
+    super(
+      "7056: Withdraw queue accounts must be present when reserve has not enough freely-available liquidity"
+    )
+  }
+}
+
+export class WithdrawTicketCallbackAccountingMismatch extends Error {
+  static readonly code = 7057
+  readonly code = 7057
+  readonly name = "WithdrawTicketCallbackAccountingMismatch"
+  readonly msg =
+    "Accounting updated by withdraw ticket callback does not match actual vault balance"
+
+  constructor(readonly logs?: string[]) {
+    super(
+      "7057: Accounting updated by withdraw ticket callback does not match actual vault balance"
+    )
+  }
+}
+
+export class NotEnoughAvailableLiquidityToInvestIntoVirtual extends Error {
+  static readonly code = 7058
+  readonly code = 7058
+  readonly name = "NotEnoughAvailableLiquidityToInvestIntoVirtual"
+  readonly msg =
+    "Insufficient available liquidity and no source reserve provided"
+
+  constructor(readonly logs?: string[]) {
+    super(
+      "7058: Insufficient available liquidity and no source reserve provided"
+    )
+  }
+}
+
+export class NotEnoughCTokensToWithdrawFromReserve extends Error {
+  static readonly code = 7059
+  readonly code = 7059
+  readonly name = "NotEnoughCTokensToWithdrawFromReserve"
+  readonly msg = "Reserve allocation is lower than requested ctokens"
+
+  constructor(readonly logs?: string[]) {
+    super("7059: Reserve allocation is lower than requested ctokens")
+  }
+}
+
+export class ReserveTokenAllocationCapExceeded extends Error {
+  static readonly code = 7060
+  readonly code = 7060
+  readonly name = "ReserveTokenAllocationCapExceeded"
+  readonly msg =
+    "Cannot invest tokens that would exceed the reserve allocation cap"
+
+  constructor(readonly logs?: string[]) {
+    super(
+      "7060: Cannot invest tokens that would exceed the reserve allocation cap"
+    )
+  }
+}
+
+export class AUMDecreasedAfterInvestInVirtualReserve extends Error {
+  static readonly code = 7061
+  readonly code = 7061
+  readonly name = "AUMDecreasedAfterInvestInVirtualReserve"
+  readonly msg = "AUM decreased after invest in virtual reserve"
+
+  constructor(readonly logs?: string[]) {
+    super("7061: AUM decreased after invest in virtual reserve")
+  }
+}
+
+export class DestinationReserveIsNotVirtual extends Error {
+  static readonly code = 7062
+  readonly code = 7062
+  readonly name = "DestinationReserveIsNotVirtual"
+  readonly msg = "Destination reserve is not virtual"
+
+  constructor(readonly logs?: string[]) {
+    super("7062: Destination reserve is not virtual")
+  }
+}
+
+export class AllSourceAccountsMustBeProvided extends Error {
+  static readonly code = 7063
+  readonly code = 7063
+  readonly name = "AllSourceAccountsMustBeProvided"
+  readonly msg = "All source accounts must be provided"
+
+  constructor(readonly logs?: string[]) {
+    super("7063: All source accounts must be provided")
+  }
+}
+
+export class InvestAndFillVaultStateMismatch extends Error {
+  static readonly code = 7064
+  readonly code = 7064
+  readonly name = "InvestAndFillVaultStateMismatch"
+  readonly msg = "Invest and fill vault state mismatch"
+
+  constructor(readonly logs?: string[]) {
+    super("7064: Invest and fill vault state mismatch")
+  }
+}
+
+export class InvestDstAndFillReserveMismatch extends Error {
+  static readonly code = 7065
+  readonly code = 7065
+  readonly name = "InvestDstAndFillReserveMismatch"
+  readonly msg = "Invest dst and fill reserve mismatch"
+
+  constructor(readonly logs?: string[]) {
+    super("7065: Invest dst and fill reserve mismatch")
+  }
+}
+
 export function fromCode(code: number, logs?: string[]): CustomError | null {
   switch (code) {
     case 7000:
@@ -792,6 +924,26 @@ export function fromCode(code: number, logs?: string[]): CustomError | null {
       return new ReserveNotWhitelisted(logs)
     case 7055:
       return new InvalidBoolLikeValue(logs)
+    case 7056:
+      return new MissingWithdrawQueueAccounts(logs)
+    case 7057:
+      return new WithdrawTicketCallbackAccountingMismatch(logs)
+    case 7058:
+      return new NotEnoughAvailableLiquidityToInvestIntoVirtual(logs)
+    case 7059:
+      return new NotEnoughCTokensToWithdrawFromReserve(logs)
+    case 7060:
+      return new ReserveTokenAllocationCapExceeded(logs)
+    case 7061:
+      return new AUMDecreasedAfterInvestInVirtualReserve(logs)
+    case 7062:
+      return new DestinationReserveIsNotVirtual(logs)
+    case 7063:
+      return new AllSourceAccountsMustBeProvided(logs)
+    case 7064:
+      return new InvestAndFillVaultStateMismatch(logs)
+    case 7065:
+      return new InvestDstAndFillReserveMismatch(logs)
   }
 
   return null

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

@@ -60,3 +60,13 @@ export type {
   AddUpdateWhitelistedReserveArgs,
   AddUpdateWhitelistedReserveAccounts,
 } from "./addUpdateWhitelistedReserve"
+export { investInVirtualReserveAndFillOrder } from "./investInVirtualReserveAndFillOrder"
+export type {
+  InvestInVirtualReserveAndFillOrderArgs,
+  InvestInVirtualReserveAndFillOrderAccounts,
+} from "./investInVirtualReserveAndFillOrder"
+export { investInVirtualReserveAndFillWithdrawalTicket } from "./investInVirtualReserveAndFillWithdrawalTicket"
+export type {
+  InvestInVirtualReserveAndFillWithdrawalTicketArgs,
+  InvestInVirtualReserveAndFillWithdrawalTicketAccounts,
+} from "./investInVirtualReserveAndFillWithdrawalTicket"

package/src/@codegen/kvault/instructions/invest.ts

@@ -35,7 +35,16 @@ export interface InvestAccounts {
   klendProgram: Address
   reserveCollateralTokenProgram: Address
   tokenProgram: Address
+  /** Required by the klend CPI. */
   instructionSysvarAccount: Address
+  /** The ticket to be initialized, if the klend's withdraw queue should be used for uninvesting. */
+  reserveWithdrawTicket: Option<Address>
+  /**
+   * The ctokens vault expected by the klend's withdraw queue.
+   * Must be present together with the `reserve_withdraw_ticket`.
+   */
+  ownerQueuedCollateralVault: Option<Address>
+  systemProgram: Address
 }
 
 export function invest(
@@ -63,6 +72,13 @@ export function invest(
     { address: accounts.reserveCollateralTokenProgram, role: 0 },
     { address: accounts.tokenProgram, role: 0 },
     { address: accounts.instructionSysvarAccount, role: 0 },
+    isSome(accounts.reserveWithdrawTicket)
+      ? { address: accounts.reserveWithdrawTicket.value, role: 1 }
+      : { address: programAddress, role: 0 },
+    isSome(accounts.ownerQueuedCollateralVault)
+      ? { address: accounts.ownerQueuedCollateralVault.value, role: 1 }
+      : { address: programAddress, role: 0 },
+    { address: accounts.systemProgram, role: 0 },
     ...remainingAccounts,
   ]
   const data = DISCRIMINATOR