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

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

@@ -0,0 +1,89 @@
+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 interface StandardJSON {
+  kind: "Standard"
+}
+
+export class Standard {
+  static readonly discriminator = 0
+  static readonly kind = "Standard"
+  readonly discriminator = 0
+  readonly kind = "Standard"
+
+  toJSON(): StandardJSON {
+    return {
+      kind: "Standard",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Standard: {},
+    }
+  }
+}
+
+export interface VirtualJSON {
+  kind: "Virtual"
+}
+
+export class Virtual {
+  static readonly discriminator = 1
+  static readonly kind = "Virtual"
+  readonly discriminator = 1
+  readonly kind = "Virtual"
+
+  toJSON(): VirtualJSON {
+    return {
+      kind: "Virtual",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Virtual: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.ReserveTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Standard" in obj) {
+    return new Standard()
+  }
+  if ("Virtual" in obj) {
+    return new Virtual()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.ReserveTypeJSON): types.ReserveTypeKind {
+  switch (obj.kind) {
+    case "Standard": {
+      return new Standard()
+    }
+    case "Virtual": {
+      return new Virtual()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Standard"),
+    borsh.struct([], "Virtual"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

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

@@ -11,10 +11,28 @@ export interface VaultAllocationFields {
   /** Maximum token invested in this reserve */
   tokenAllocationCap: BN
   ctokenVaultBump: BN
+  /** should match the ReserveType enum */
+  reserveType: number
+  padding0: Array<number>
   configPadding: Array<BN>
+  /**
+   * The amount of ctokens that currently earns yield for the vault.
+   *
+   * Please note that these ctokens are *not* necessarily all in the [Self::ctoken_vault] - they
+   * may also be e.g. queued for withdrawal (and held by the corresponding Klend queue vault),
+   * see [Self::klend_queued_ctokens].
+   */
   ctokenAllocation: BN
   lastInvestSlot: BN
   tokenTargetAllocationSf: BN
+  /**
+   * The ctokens that are still locked in the [Self::reserve]'s "queued collateral vault" on the
+   * Klend's withdraw queue side.
+   *
+   * Please note that - since such queued ctokens still earn yield for the vault - this amount is
+   * also included in the [Self::ctoken_allocation].
+   */
+  klendQueuedCtokens: BN
   statePadding: Array<BN>
 }
 
@@ -25,10 +43,28 @@ export interface VaultAllocationJSON {
   /** Maximum token invested in this reserve */
   tokenAllocationCap: string
   ctokenVaultBump: string
+  /** should match the ReserveType enum */
+  reserveType: number
+  padding0: Array<number>
   configPadding: Array<string>
+  /**
+   * The amount of ctokens that currently earns yield for the vault.
+   *
+   * Please note that these ctokens are *not* necessarily all in the [Self::ctoken_vault] - they
+   * may also be e.g. queued for withdrawal (and held by the corresponding Klend queue vault),
+   * see [Self::klend_queued_ctokens].
+   */
   ctokenAllocation: string
   lastInvestSlot: string
   tokenTargetAllocationSf: string
+  /**
+   * The ctokens that are still locked in the [Self::reserve]'s "queued collateral vault" on the
+   * Klend's withdraw queue side.
+   *
+   * Please note that - since such queued ctokens still earn yield for the vault - this amount is
+   * also included in the [Self::ctoken_allocation].
+   */
+  klendQueuedCtokens: string
   statePadding: Array<string>
 }
 
@@ -39,10 +75,28 @@ export class VaultAllocation {
   /** Maximum token invested in this reserve */
   readonly tokenAllocationCap: BN
   readonly ctokenVaultBump: BN
+  /** should match the ReserveType enum */
+  readonly reserveType: number
+  readonly padding0: Array<number>
   readonly configPadding: Array<BN>
+  /**
+   * The amount of ctokens that currently earns yield for the vault.
+   *
+   * Please note that these ctokens are *not* necessarily all in the [Self::ctoken_vault] - they
+   * may also be e.g. queued for withdrawal (and held by the corresponding Klend queue vault),
+   * see [Self::klend_queued_ctokens].
+   */
   readonly ctokenAllocation: BN
   readonly lastInvestSlot: BN
   readonly tokenTargetAllocationSf: BN
+  /**
+   * The ctokens that are still locked in the [Self::reserve]'s "queued collateral vault" on the
+   * Klend's withdraw queue side.
+   *
+   * Please note that - since such queued ctokens still earn yield for the vault - this amount is
+   * also included in the [Self::ctoken_allocation].
+   */
+  readonly klendQueuedCtokens: BN
   readonly statePadding: Array<BN>
 
   constructor(fields: VaultAllocationFields) {
@@ -51,10 +105,13 @@ export class VaultAllocation {
     this.targetAllocationWeight = fields.targetAllocationWeight
     this.tokenAllocationCap = fields.tokenAllocationCap
     this.ctokenVaultBump = fields.ctokenVaultBump
+    this.reserveType = fields.reserveType
+    this.padding0 = fields.padding0
     this.configPadding = fields.configPadding
     this.ctokenAllocation = fields.ctokenAllocation
     this.lastInvestSlot = fields.lastInvestSlot
     this.tokenTargetAllocationSf = fields.tokenTargetAllocationSf
+    this.klendQueuedCtokens = fields.klendQueuedCtokens
     this.statePadding = fields.statePadding
   }
 
@@ -66,11 +123,14 @@ export class VaultAllocation {
         borsh.u64("targetAllocationWeight"),
         borsh.u64("tokenAllocationCap"),
         borsh.u64("ctokenVaultBump"),
-        borsh.array(borsh.u64(), 127, "configPadding"),
+        borsh.u8("reserveType"),
+        borsh.array(borsh.u8(), 7, "padding0"),
+        borsh.array(borsh.u64(), 126, "configPadding"),
         borsh.u64("ctokenAllocation"),
         borsh.u64("lastInvestSlot"),
         borsh.u128("tokenTargetAllocationSf"),
-        borsh.array(borsh.u64(), 128, "statePadding"),
+        borsh.u64("klendQueuedCtokens"),
+        borsh.array(borsh.u64(), 127, "statePadding"),
       ],
       property
     )
@@ -84,10 +144,13 @@ export class VaultAllocation {
       targetAllocationWeight: obj.targetAllocationWeight,
       tokenAllocationCap: obj.tokenAllocationCap,
       ctokenVaultBump: obj.ctokenVaultBump,
+      reserveType: obj.reserveType,
+      padding0: obj.padding0,
       configPadding: obj.configPadding,
       ctokenAllocation: obj.ctokenAllocation,
       lastInvestSlot: obj.lastInvestSlot,
       tokenTargetAllocationSf: obj.tokenTargetAllocationSf,
+      klendQueuedCtokens: obj.klendQueuedCtokens,
       statePadding: obj.statePadding,
     })
   }
@@ -99,10 +162,13 @@ export class VaultAllocation {
       targetAllocationWeight: fields.targetAllocationWeight,
       tokenAllocationCap: fields.tokenAllocationCap,
       ctokenVaultBump: fields.ctokenVaultBump,
+      reserveType: fields.reserveType,
+      padding0: fields.padding0,
       configPadding: fields.configPadding,
       ctokenAllocation: fields.ctokenAllocation,
       lastInvestSlot: fields.lastInvestSlot,
       tokenTargetAllocationSf: fields.tokenTargetAllocationSf,
+      klendQueuedCtokens: fields.klendQueuedCtokens,
       statePadding: fields.statePadding,
     }
   }
@@ -114,10 +180,13 @@ export class VaultAllocation {
       targetAllocationWeight: this.targetAllocationWeight.toString(),
       tokenAllocationCap: this.tokenAllocationCap.toString(),
       ctokenVaultBump: this.ctokenVaultBump.toString(),
+      reserveType: this.reserveType,
+      padding0: this.padding0,
       configPadding: this.configPadding.map((item) => item.toString()),
       ctokenAllocation: this.ctokenAllocation.toString(),
       lastInvestSlot: this.lastInvestSlot.toString(),
       tokenTargetAllocationSf: this.tokenTargetAllocationSf.toString(),
+      klendQueuedCtokens: this.klendQueuedCtokens.toString(),
       statePadding: this.statePadding.map((item) => item.toString()),
     }
   }
@@ -129,10 +198,13 @@ export class VaultAllocation {
       targetAllocationWeight: new BN(obj.targetAllocationWeight),
       tokenAllocationCap: new BN(obj.tokenAllocationCap),
       ctokenVaultBump: new BN(obj.ctokenVaultBump),
+      reserveType: obj.reserveType,
+      padding0: obj.padding0,
       configPadding: obj.configPadding.map((item) => new BN(item)),
       ctokenAllocation: new BN(obj.ctokenAllocation),
       lastInvestSlot: new BN(obj.lastInvestSlot),
       tokenTargetAllocationSf: new BN(obj.tokenTargetAllocationSf),
+      klendQueuedCtokens: new BN(obj.klendQueuedCtokens),
       statePadding: obj.statePadding.map((item) => new BN(item)),
     })
   }

package/src/@codegen/kvault/types/WithdrawQueue.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 interface WithdrawQueueFields {
+  /** The part of [ReserveLiquidity::total_available_amount] locked for ticketed withdrawals. */
+  queuedCollateralAmount: BN
+  /**
+   * The sequence number of the next ticket to be issued when enqueueing to withdraw.
+   * Note: it is also a number of tickets issued so far.
+   */
+  nextIssuedTicketSequenceNumber: BN
+  /**
+   * The sequence number of the next ticket to be used for actually transferring the withdrawn
+   * liquidity (assuming it is available in the reserve).
+   * Note: it is also a number of fully-consumed tickets so far.
+   */
+  nextWithdrawableTicketSequenceNumber: BN
+}
+
+export interface WithdrawQueueJSON {
+  /** The part of [ReserveLiquidity::total_available_amount] locked for ticketed withdrawals. */
+  queuedCollateralAmount: string
+  /**
+   * The sequence number of the next ticket to be issued when enqueueing to withdraw.
+   * Note: it is also a number of tickets issued so far.
+   */
+  nextIssuedTicketSequenceNumber: string
+  /**
+   * The sequence number of the next ticket to be used for actually transferring the withdrawn
+   * liquidity (assuming it is available in the reserve).
+   * Note: it is also a number of fully-consumed tickets so far.
+   */
+  nextWithdrawableTicketSequenceNumber: string
+}
+
+/** A tracker of ticket-based withdrawals. */
+export class WithdrawQueue {
+  /** The part of [ReserveLiquidity::total_available_amount] locked for ticketed withdrawals. */
+  readonly queuedCollateralAmount: BN
+  /**
+   * The sequence number of the next ticket to be issued when enqueueing to withdraw.
+   * Note: it is also a number of tickets issued so far.
+   */
+  readonly nextIssuedTicketSequenceNumber: BN
+  /**
+   * The sequence number of the next ticket to be used for actually transferring the withdrawn
+   * liquidity (assuming it is available in the reserve).
+   * Note: it is also a number of fully-consumed tickets so far.
+   */
+  readonly nextWithdrawableTicketSequenceNumber: BN
+
+  constructor(fields: WithdrawQueueFields) {
+    this.queuedCollateralAmount = fields.queuedCollateralAmount
+    this.nextIssuedTicketSequenceNumber = fields.nextIssuedTicketSequenceNumber
+    this.nextWithdrawableTicketSequenceNumber =
+      fields.nextWithdrawableTicketSequenceNumber
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u64("queuedCollateralAmount"),
+        borsh.u64("nextIssuedTicketSequenceNumber"),
+        borsh.u64("nextWithdrawableTicketSequenceNumber"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new WithdrawQueue({
+      queuedCollateralAmount: obj.queuedCollateralAmount,
+      nextIssuedTicketSequenceNumber: obj.nextIssuedTicketSequenceNumber,
+      nextWithdrawableTicketSequenceNumber:
+        obj.nextWithdrawableTicketSequenceNumber,
+    })
+  }
+
+  static toEncodable(fields: WithdrawQueueFields) {
+    return {
+      queuedCollateralAmount: fields.queuedCollateralAmount,
+      nextIssuedTicketSequenceNumber: fields.nextIssuedTicketSequenceNumber,
+      nextWithdrawableTicketSequenceNumber:
+        fields.nextWithdrawableTicketSequenceNumber,
+    }
+  }
+
+  toJSON(): WithdrawQueueJSON {
+    return {
+      queuedCollateralAmount: this.queuedCollateralAmount.toString(),
+      nextIssuedTicketSequenceNumber:
+        this.nextIssuedTicketSequenceNumber.toString(),
+      nextWithdrawableTicketSequenceNumber:
+        this.nextWithdrawableTicketSequenceNumber.toString(),
+    }
+  }
+
+  static fromJSON(obj: WithdrawQueueJSON): WithdrawQueue {
+    return new WithdrawQueue({
+      queuedCollateralAmount: new BN(obj.queuedCollateralAmount),
+      nextIssuedTicketSequenceNumber: new BN(
+        obj.nextIssuedTicketSequenceNumber
+      ),
+      nextWithdrawableTicketSequenceNumber: new BN(
+        obj.nextWithdrawableTicketSequenceNumber
+      ),
+    })
+  }
+
+  toEncodable() {
+    return WithdrawQueue.toEncodable(this)
+  }
+}

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

@@ -0,0 +1,59 @@
+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 interface QueuedLiquidityWithdrawnJSON {
+  kind: "QueuedLiquidityWithdrawn"
+}
+
+export class QueuedLiquidityWithdrawn {
+  static readonly discriminator = 0
+  static readonly kind = "QueuedLiquidityWithdrawn"
+  readonly discriminator = 0
+  readonly kind = "QueuedLiquidityWithdrawn"
+
+  toJSON(): QueuedLiquidityWithdrawnJSON {
+    return {
+      kind: "QueuedLiquidityWithdrawn",
+    }
+  }
+
+  toEncodable() {
+    return {
+      QueuedLiquidityWithdrawn: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.WithdrawTicketProgressEventKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("QueuedLiquidityWithdrawn" in obj) {
+    return new QueuedLiquidityWithdrawn()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.WithdrawTicketProgressEventJSON
+): types.WithdrawTicketProgressEventKind {
+  switch (obj.kind) {
+    case "QueuedLiquidityWithdrawn": {
+      return new QueuedLiquidityWithdrawn()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([borsh.struct([], "QueuedLiquidityWithdrawn")])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

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

@@ -1,9 +1,35 @@
+import * as WithdrawTicketProgressEvent from "./WithdrawTicketProgressEvent"
 import * as UpdateReserveWhitelistMode from "./UpdateReserveWhitelistMode"
 import * as VaultConfigField from "./VaultConfigField"
 import * as UpdateGlobalConfigMode from "./UpdateGlobalConfigMode"
+import * as ReserveType from "./ReserveType"
 
 export { LastUpdate } from "./LastUpdate"
 export type { LastUpdateFields, LastUpdateJSON } from "./LastUpdate"
+export { ElevationGroup } from "./ElevationGroup"
+export type { ElevationGroupFields, ElevationGroupJSON } from "./ElevationGroup"
+export { BorrowOrder } from "./BorrowOrder"
+export type { BorrowOrderFields, BorrowOrderJSON } from "./BorrowOrder"
+export { FixedTermBorrowRolloverConfig } from "./FixedTermBorrowRolloverConfig"
+export type {
+  FixedTermBorrowRolloverConfigFields,
+  FixedTermBorrowRolloverConfigJSON,
+} from "./FixedTermBorrowRolloverConfig"
+export { ObligationCollateral } from "./ObligationCollateral"
+export type {
+  ObligationCollateralFields,
+  ObligationCollateralJSON,
+} from "./ObligationCollateral"
+export { ObligationLiquidity } from "./ObligationLiquidity"
+export type {
+  ObligationLiquidityFields,
+  ObligationLiquidityJSON,
+} from "./ObligationLiquidity"
+export { ObligationOrder } from "./ObligationOrder"
+export type {
+  ObligationOrderFields,
+  ObligationOrderJSON,
+} from "./ObligationOrder"
 export { BigFractionBytes } from "./BigFractionBytes"
 export type {
   BigFractionBytesFields,
@@ -23,6 +49,8 @@ export type {
   ReserveLiquidityFields,
   ReserveLiquidityJSON,
 } from "./ReserveLiquidity"
+export { WithdrawQueue } from "./WithdrawQueue"
+export type { WithdrawQueueFields, WithdrawQueueJSON } from "./WithdrawQueue"
 export { WithdrawalCaps } from "./WithdrawalCaps"
 export type { WithdrawalCapsFields, WithdrawalCapsJSON } from "./WithdrawalCaps"
 export { PriceHeuristic } from "./PriceHeuristic"
@@ -44,6 +72,13 @@ export type {
 } from "./SwitchboardConfiguration"
 export { TokenInfo } from "./TokenInfo"
 export type { TokenInfoFields, TokenInfoJSON } from "./TokenInfo"
+export { WithdrawTicketProgressEvent }
+
+export type WithdrawTicketProgressEventKind =
+  WithdrawTicketProgressEvent.QueuedLiquidityWithdrawn
+export type WithdrawTicketProgressEventJSON =
+  WithdrawTicketProgressEvent.QueuedLiquidityWithdrawnJSON
+
 export { BorrowRateCurve } from "./BorrowRateCurve"
 export type {
   BorrowRateCurveFields,
@@ -118,3 +153,20 @@ export type UpdateGlobalConfigModeJSON =
   | UpdateGlobalConfigMode.PendingAdminJSON
   | UpdateGlobalConfigMode.MinWithdrawalPenaltyLamportsJSON
   | UpdateGlobalConfigMode.MinWithdrawalPenaltyBPSJSON
+
+export { ReserveType }
+
+/**
+ * The type of the reserve determine how investing and uninvesting (mechanisms + the way to compute how much should be invested/uninvested) works
+ *
+ * Standard:
+ * - investing happens through the `invest` handler and the amount invested is computed based on the weight of the reserve, from the vault AUM - the amount invested in virtual reserves
+ *
+ * Virtual (i.e. the allocation can be moved to that reserve if needed, so it is virtually there but will be allocated only if needed by a borrow order or reserve withdrawal ticket):
+ * - investing in a virtual reserve doesn't happen through the `invest` handler but using a dedicated handler which ensures that the amount to be invested fills (fully or partially) a borrow order or a reserve withdrawal ticket
+ * - has a higher allocation priority comparing to the Standard reserves and can disinvest from a Standard reserve and invest into the Virtual one if needed
+ * -the weight is not used for virtual reserves, only the cap is limiting the amount that can be invested in the reserve, and calling `invest` on a virtual reserve will disinvest if the amount invested exceeds the cap
+ * - current main use case is for fixed term reserves, such that the manager decides their desired max exposure to a fixed term reserve and anytime there is an order or withdrawal ticket we invest into the fixed term reserve until the cap is reached or the order/ticket is filled
+ */
+export type ReserveTypeKind = ReserveType.Standard | ReserveType.Virtual
+export type ReserveTypeJSON = ReserveType.StandardJSON | ReserveType.VirtualJSON

package/src/classes/action.ts

@@ -23,6 +23,7 @@ import {
   depositReserveLiquidity,
   depositReserveLiquidityAndObligationCollateral,
   depositReserveLiquidityAndObligationCollateralV2,
+  enqueueToWithdraw,
   initObligation,
   initObligationFarmsForReserve,
   InitObligationFarmsForReserveAccounts,
@@ -46,6 +47,7 @@ import {
   setObligationOrder,
   withdrawObligationCollateralAndRedeemReserveCollateral,
   withdrawObligationCollateralAndRedeemReserveCollateralV2,
+  withdrawQueuedLiquidity,
   withdrawReferrerFees,
 } from '../@codegen/klend/instructions';
 import {
@@ -58,17 +60,19 @@ import {
   isNotNullPubkey,
   obligationFarmStatePda,
   ObligationType,
+  ownerQueuedCollateralVaultPda,
   referrerTokenStatePda,
   ScopePriceRefreshConfig,
   SOL_PADDING_FOR_INTEREST,
   U64_MAX,
   userMetadataPda,
+  withdrawTicketPda,
   WRAPPED_SOL_MINT,
 } from '../utils';
 import { getTokenIdsForScopeRefresh, KaminoMarket } from './market';
 import { isKaminoObligation, KaminoObligation } from './obligation';
 import { KaminoReserve } from './reserve';
-import { ReserveFarmKind } from '../@codegen/klend/types';
+import { ProgressCallbackType, ReserveFarmKind } from '../@codegen/klend/types';
 import { PROGRAM_ID as FARMS_PROGRAM_ID } from '@kamino-finance/farms-sdk/dist/@codegen/farms/programId';
 import { Reserve } from '../@codegen/klend/accounts';
 import { VanillaObligation } from '../utils/ObligationType';
@@ -1174,6 +1178,116 @@ export class KaminoAction {
     );
   }
 
+  /**
+   * Builds an instruction for enqueueing a withdrawal request to the withdraw queue.
+   * This is used when there isn't enough liquidity to immediately withdraw.
+   */
+  static async buildEnqueueToWithdrawIx(
+    owner: TransactionSigner,
+    kaminoMarket: KaminoMarket,
+    reserve: KaminoReserve,
+    collateralAmount: BN,
+    userDestinationLiquidityTa: Address,
+    progressCallbackType: ProgressCallbackType.None | ProgressCallbackType.KlendQueueAccountingHandlerOnKvault = new ProgressCallbackType.None(),
+    progressCallbackCustomAccount0: Option<Address> = none(),
+    progressCallbackCustomAccount1: Option<Address> = none()
+  ): Promise<Instruction> {
+    const lendingMarketAuthority = await kaminoMarket.getLendingMarketAuthority();
+    const userSourceCollateralTa = await getAssociatedTokenAddress(reserve.getCTokenMint(), owner.address);
+    const withdrawTicket = await withdrawTicketPda(
+      reserve.address,
+      BigInt(reserve.state.withdrawQueue.nextIssuedTicketSequenceNumber.toString()),
+      kaminoMarket.programId
+    );
+    const ownerQueuedCollateralVault = await ownerQueuedCollateralVaultPda(
+      reserve.address,
+      owner.address,
+      kaminoMarket.programId
+    );
+
+    return enqueueToWithdraw(
+      {
+        collateralAmount,
+        progressCallbackType,
+      },
+      {
+        owner,
+        lendingMarket: kaminoMarket.getAddress(),
+        lendingMarketAuthority,
+        reserve: reserve.address,
+        userSourceCollateralTa,
+        userDestinationLiquidityTa,
+        reserveLiquidityMint: reserve.getLiquidityMint(),
+        reserveCollateralMint: reserve.getCTokenMint(),
+        collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
+        withdrawTicket,
+        ownerQueuedCollateralVault,
+        systemProgram: SYSTEM_PROGRAM_ADDRESS,
+        progressCallbackCustomAccount0,
+        progressCallbackCustomAccount1,
+      },
+      undefined,
+      kaminoMarket.programId
+    );
+  }
+
+  /**
+   * Builds an instruction for withdrawing queued liquidity (permissionless).
+   * This allows anyone to process a withdraw ticket when liquidity becomes available.
+   */
+  static async buildWithdrawQueuedLiquidityIx(
+    payer: TransactionSigner,
+    kaminoMarket: KaminoMarket,
+    reserve: KaminoReserve,
+    withdrawTicket: Address,
+    withdrawTicketOwner: Address,
+    userDestinationLiquidity: Address,
+    progressCallbackProgram: Option<Address> = none(),
+    progressCallbackCustomAccount0: Option<Address> = none(),
+    progressCallbackCustomAccount1: Option<Address> = none()
+  ): Promise<Instruction> {
+    const lendingMarketAuthority = await kaminoMarket.getLendingMarketAuthority();
+    const resolvedProgressCallbackProgram = isNone(progressCallbackProgram)
+      ? some(SYSTEM_PROGRAM_ADDRESS)
+      : progressCallbackProgram;
+    const resolvedProgressCallbackCustomAccount0 = isNone(progressCallbackCustomAccount0)
+      ? some(SYSTEM_PROGRAM_ADDRESS)
+      : progressCallbackCustomAccount0;
+    const resolvedProgressCallbackCustomAccount1 = isNone(progressCallbackCustomAccount1)
+      ? some(SYSTEM_PROGRAM_ADDRESS)
+      : progressCallbackCustomAccount1;
+    const ownerQueuedCollateralVault = await ownerQueuedCollateralVaultPda(
+      reserve.address,
+      withdrawTicketOwner,
+      kaminoMarket.programId
+    );
+
+    return withdrawQueuedLiquidity(
+      {
+        payer,
+        lendingMarket: kaminoMarket.getAddress(),
+        lendingMarketAuthority,
+        reserve: reserve.address,
+        reserveLiquidityMint: reserve.getLiquidityMint(),
+        reserveCollateralMint: reserve.getCTokenMint(),
+        reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
+        ownerQueuedCollateralVault,
+        userDestinationLiquidity,
+        collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
+        liquidityTokenProgram: reserve.getLiquidityTokenProgram(),
+        withdrawTicket,
+        withdrawTicketOwner,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+        systemProgram: SYSTEM_PROGRAM_ADDRESS,
+        progressCallbackProgram: resolvedProgressCallbackProgram,
+        progressCallbackCustomAccount0: resolvedProgressCallbackCustomAccount0,
+        progressCallbackCustomAccount1: resolvedProgressCallbackCustomAccount1,
+      },
+      undefined,
+      kaminoMarket.programId
+    );
+  }
+
   async addDepositReserveLiquidityIx() {
     this.lendingIxsLabels.push(`depositReserveLiquidity`);
     this.lendingIxs.push(