@kamino-finance/klend-sdk 7.3.10-beta.0 → 7.3.10-beta.1

package/src/client/client.ts

@@ -32,15 +32,15 @@ async function main() {
   commands
     .command('print-borrow-rate')
     .option(`--url <string>`, 'The admin keypair file')
-    .option(`--token <string>`, 'The token symbol')
+    .option(`--reserveAddress <string>`, 'The token symbol')
     .option(`--cluster <string>`, 'staging or mainnet-beta')
-    .action(async ({ url, token, cluster }) => {
+    .action(async ({ url, reserveAddress, cluster }) => {
       const env = await initEnv(url);
 
       const programId = getProgramId(cluster);
       const kaminoMarket = await getMarket(env.c.rpc, programId);
 
-      const reserve = kaminoMarket.getReserveBySymbol(token);
+      const reserve = kaminoMarket.getReserveByAddress(reserveAddress);
 
       const slot = await env.c.rpc.getSlot().send();
 
@@ -130,10 +130,9 @@ async function main() {
     .command('print-reserve')
     .option(`--url <string>`, 'The admin keypair file')
     .option(`--reserve <string>`, 'Reserve address')
-    .option(`--symbol <string>`, 'Symbol (optional)')
-    .action(async ({ url, reserve, symbol }) => {
+    .action(async ({ url, reserve }) => {
       const env = await initEnv(url);
-      await printReserve(env.c.rpc, reserve, symbol);
+      await printReserve(env.c.rpc, reserve);
     });
 
   commands
@@ -148,48 +147,48 @@ async function main() {
     .command('deposit')
     .option(`--url <string>`, 'Custom RPC URL')
     .option(`--owner <string>`, 'Custom RPC URL')
-    .option(`--token <string>`, 'Custom RPC URL')
+    .option(`--reserveAddress <string>`, 'Custom RPC URL')
     .option(`--amount <string>`, 'Custom RPC URL')
-    .action(async ({ url, owner, token, amount }) => {
+    .action(async ({ url, owner, reserveAddress, amount }) => {
       const depositAmount = new BN(amount);
       const env = await initEnv(url, owner);
-      await deposit(env, 'execute', token, depositAmount);
+      await deposit(env, 'execute', reserveAddress, depositAmount);
     });
 
   commands
     .command('withdraw')
     .option(`--url <string>`, 'Custom RPC URL')
     .option(`--owner <string>`, 'Custom RPC URL')
-    .option(`--token <string>`, 'Custom RPC URL')
+    .option(`--reserveAddress <string>`, 'Custom RPC URL')
     .option(`--amount <string>`, 'Custom RPC URL')
-    .action(async ({ url, owner, token, amount }) => {
+    .action(async ({ url, owner, reserveAddress, amount }) => {
       const withdrawAmount = new BN(amount);
       const env = await initEnv(url, owner);
-      await withdraw(env, 'execute', token, withdrawAmount);
+      await withdraw(env, 'execute', reserveAddress, withdrawAmount);
     });
 
   commands
     .command('borrow')
     .option(`--url <string>`, 'Custom RPC URL')
     .option(`--owner <string>`, 'Custom RPC URL')
-    .option(`--token <string>`, 'Custom RPC URL')
+    .option(`--reserveAddress <string>`, 'Custom RPC URL')
     .option(`--amount <string>`, 'Custom RPC URL')
-    .action(async ({ url, owner, token, amount }) => {
+    .action(async ({ url, owner, reserveAddress, amount }) => {
       const borrowAmount = new BN(amount);
       const env = await initEnv(url, owner);
-      await borrow(env, 'execute', token, borrowAmount);
+      await borrow(env, 'execute', reserveAddress, borrowAmount);
     });
 
   commands
     .command('repay')
     .option(`--url <string>`, 'Custom RPC URL')
     .option(`--owner <string>`, 'Custom RPC URL')
-    .option(`--token <string>`, 'Custom RPC URL')
+    .option(`--reserveAddress <string>`, 'Custom RPC URL')
     .option(`--amount <string>`, 'Custom RPC URL')
-    .action(async ({ url, owner, token, amount }) => {
+    .action(async ({ url, owner, reserveAddress, amount }) => {
       const repayAmount = new BN(amount);
       const env = await initEnv(url, owner);
-      await repay(env, 'execute', token, repayAmount);
+      await repay(env, 'execute', reserveAddress, repayAmount);
     });
 
   commands

package/src/client/commands/borrow.ts

@@ -5,21 +5,22 @@ import { KaminoAction } from '../../classes';
 import { Scope } from '@kamino-finance/scope-sdk';
 import { CliEnv, SendTxMode } from '../tx/CliEnv';
 import { processTx } from '../tx/processor';
+import { address } from '@solana/kit';
 
-export async function borrow(env: CliEnv, mode: SendTxMode, token: string, borrowAmount: BN): Promise<void> {
+export async function borrow(env: CliEnv, mode: SendTxMode, reserveAddress: string, borrowAmount: BN): Promise<void> {
   const signer = await env.getSigner();
   const programId = getProgramId('staging');
   const kaminoMarket = await getMarket(env.c.rpc, programId);
   const scope = new Scope('mainnet-beta', env.c.rpc);
-  const kaminoAction = await KaminoAction.buildBorrowTxns(
+  const kaminoAction = await KaminoAction.buildBorrowTxns({
     kaminoMarket,
-    borrowAmount,
-    kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
-    signer,
-    new VanillaObligation(STAGING_LENDING_MARKET),
-    true,
-    { scope, scopeConfigurations: await scope.getAllConfigurations() }
-  );
+    amount: borrowAmount,
+    reserveAddress: address(reserveAddress),
+    owner: signer,
+    obligation: new VanillaObligation(STAGING_LENDING_MARKET),
+    useV2Ixs: true,
+    scopeRefreshConfig: { scope, scopeConfigurations: await scope.getAllConfigurations() },
+  });
   console.log('User obligation', await kaminoAction.getObligationPda());
 
   console.log('Borrow SetupIxs:', kaminoAction.setupIxsLabels);

package/src/client/commands/deposit.ts

@@ -5,21 +5,22 @@ import { Scope } from '@kamino-finance/scope-sdk';
 import { CliEnv, SendTxMode } from '../tx/CliEnv';
 import { getMarket, STAGING_LENDING_MARKET } from '../services/market';
 import { processTx } from '../tx/processor';
+import { address } from '@solana/kit';
 
-export async function deposit(env: CliEnv, mode: SendTxMode, token: string, depositAmount: BN): Promise<void> {
+export async function deposit(env: CliEnv, mode: SendTxMode, reserveAddress: string, depositAmount: BN): Promise<void> {
   const signer = await env.getSigner();
   const programId = getProgramId('staging');
   const kaminoMarket = await getMarket(env.c.rpc, programId);
   const scope = new Scope('mainnet-beta', env.c.rpc);
-  const kaminoAction = await KaminoAction.buildDepositTxns(
+  const kaminoAction = await KaminoAction.buildDepositTxns({
     kaminoMarket,
-    depositAmount,
-    kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
-    signer,
-    new VanillaObligation(STAGING_LENDING_MARKET),
-    true,
-    { scope, scopeConfigurations: await scope.getAllConfigurations() }
-  );
+    amount: depositAmount,
+    reserveAddress: address(reserveAddress),
+    owner: signer,
+    obligation: new VanillaObligation(STAGING_LENDING_MARKET),
+    useV2Ixs: true,
+    scopeRefreshConfig: { scope, scopeConfigurations: await scope.getAllConfigurations() },
+  });
   console.log('User obligation', await kaminoAction.getObligationPda());
 
   console.log('Deposit SetupIxs:', kaminoAction.setupIxsLabels);

package/src/client/commands/printReserve.ts

@@ -2,12 +2,10 @@ import { getProgramId } from '../../utils';
 import { getMarket } from '../services/market';
 import { address, Rpc, SolanaRpcApi } from '@solana/kit';
 
-export async function printReserve(rpc: Rpc<SolanaRpcApi>, reserve?: string, symbol?: string): Promise<void> {
+export async function printReserve(rpc: Rpc<SolanaRpcApi>, reserve: string): Promise<void> {
   const programId = getProgramId('staging');
   const kaminoMarket = await getMarket(rpc, programId);
-  const result = reserve
-    ? kaminoMarket.getReserveByAddress(address(reserve))
-    : kaminoMarket.getReserveBySymbol(symbol!);
+  const result = kaminoMarket.getReserveByAddress(address(reserve));
   console.log(result);
   console.log(result?.stats?.reserveDepositLimit.toString());
 }

package/src/client/commands/repay.ts

@@ -5,22 +5,23 @@ import { KaminoAction } from '../../classes';
 import { Scope } from '@kamino-finance/scope-sdk';
 import { processTx } from '../tx/processor';
 import { CliEnv, SendTxMode } from '../tx/CliEnv';
+import { address } from '@solana/kit';
 
-export async function repay(env: CliEnv, mode: SendTxMode, token: string, borrowAmount: BN): Promise<void> {
+export async function repay(env: CliEnv, mode: SendTxMode, reserveAddress: string, borrowAmount: BN): Promise<void> {
   const signer = await env.getSigner();
   const programId = getProgramId('staging');
   const kaminoMarket = await getMarket(env.c.rpc, programId);
   const scope = new Scope('mainnet-beta', env.c.rpc);
-  const kaminoAction = await KaminoAction.buildRepayTxns(
+  const kaminoAction = await KaminoAction.buildRepayTxns({
     kaminoMarket,
-    borrowAmount,
-    kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
-    signer,
-    new VanillaObligation(STAGING_LENDING_MARKET),
-    true,
-    { scope, scopeConfigurations: await scope.getAllConfigurations() },
-    await env.c.rpc.getSlot().send()
-  );
+    amount: borrowAmount,
+    reserveAddress: address(reserveAddress),
+    owner: signer,
+    obligation: new VanillaObligation(STAGING_LENDING_MARKET),
+    useV2Ixs: true,
+    scopeRefreshConfig: { scope, scopeConfigurations: await scope.getAllConfigurations() },
+    currentSlot: await env.c.rpc.getSlot().send(),
+  });
   console.log('User obligation', await kaminoAction.getObligationPda());
 
   console.log('Repay SetupIxs:', kaminoAction.setupIxsLabels);

package/src/client/commands/withdraw.ts

@@ -5,21 +5,27 @@ import { Scope } from '@kamino-finance/scope-sdk';
 import { CliEnv, SendTxMode } from '../tx/CliEnv';
 import { getMarket, STAGING_LENDING_MARKET } from '../services/market';
 import { processTx } from '../tx/processor';
+import { address } from '@solana/kit';
 
-export async function withdraw(env: CliEnv, mode: SendTxMode, token: string, depositAmount: BN): Promise<void> {
+export async function withdraw(
+  env: CliEnv,
+  mode: SendTxMode,
+  reserveAddress: string,
+  depositAmount: BN
+): Promise<void> {
   const signer = await env.getSigner();
   const programId = getProgramId('staging');
   const kaminoMarket = await getMarket(env.c.rpc, programId);
   const scope = new Scope('mainnet-beta', env.c.rpc);
-  const kaminoAction = await KaminoAction.buildWithdrawTxns(
+  const kaminoAction = await KaminoAction.buildWithdrawTxns({
     kaminoMarket,
-    depositAmount,
-    kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
-    signer,
-    new VanillaObligation(STAGING_LENDING_MARKET),
-    true,
-    { scope, scopeConfigurations: await scope.getAllConfigurations() }
-  );
+    amount: depositAmount,
+    reserveAddress: address(reserveAddress),
+    owner: signer,
+    obligation: new VanillaObligation(STAGING_LENDING_MARKET),
+    useV2Ixs: true,
+    scopeRefreshConfig: { scope, scopeConfigurations: await scope.getAllConfigurations() },
+  });
   console.log('User obligation', await kaminoAction.getObligationPda());
 
   console.log('Withdraw SetupIxs:', kaminoAction.setupIxsLabels);

package/src/lending_operations/repay_with_collateral_calcs.ts

@@ -174,7 +174,7 @@ export function estimateDebtRepaymentWithColl(props: {
   slippagePct: Decimal;
   flashLoanFeePct: Decimal;
   kaminoMarket: KaminoMarket;
-  debtTokenMint: Address;
+  debtReserveAddress: Address;
   obligation: KaminoObligation;
   currentSlot: Slot;
 }): Decimal {
@@ -184,15 +184,14 @@ export function estimateDebtRepaymentWithColl(props: {
     slippagePct,
     flashLoanFeePct,
     kaminoMarket,
-    debtTokenMint,
+    debtReserveAddress,
     obligation,
     currentSlot,
   } = props;
   const slippageMultiplier = new Decimal(1.0).add(slippagePct.div('100'));
   const flashLoanFeeMultiplier = new Decimal(1.0).add(flashLoanFeePct.div('100'));
 
-  const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
-
+  const debtReserve = kaminoMarket.getExistingReserveByAddress(debtReserveAddress);
   const debtAfterSwap = collAmount.div(slippageMultiplier).div(priceDebtToColl);
   const debtAfterFlashLoanRepay = debtAfterSwap.div(flashLoanFeeMultiplier);
 

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -47,8 +47,8 @@ export type RepayWithCollInitialInputs<QuoteResponse> = {
 
 interface RepayWithCollSwapInputsProps<QuoteResponse> {
   kaminoMarket: KaminoMarket;
-  debtTokenMint: Address;
-  collTokenMint: Address;
+  debtReserveAddress: Address;
+  collReserveAddress: Address;
   owner: TransactionSigner;
   obligation: KaminoObligation;
   referrer: Option<Address>;
@@ -67,9 +67,9 @@ export enum MaxWithdrawLtvCheck {
 }
 
 export async function getRepayWithCollSwapInputs<QuoteResponse>({
-  collTokenMint,
+  collReserveAddress,
   currentSlot,
-  debtTokenMint,
+  debtReserveAddress,
   kaminoMarket,
   owner,
   obligation,
@@ -85,8 +85,10 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
   flashLoanInfo: FlashLoanInfo;
   initialInputs: RepayWithCollInitialInputs<QuoteResponse>;
 }> {
-  const collReserve = kaminoMarket.getExistingReserveByMint(collTokenMint);
-  const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
+  const collReserve = kaminoMarket.getExistingReserveByAddress(collReserveAddress);
+  const debtReserve = kaminoMarket.getExistingReserveByAddress(debtReserveAddress);
+  const collTokenMint = collReserve.getLiquidityMint();
+  const debtTokenMint = debtReserve.getLiquidityMint();
 
   const {
     repayAmountLamports,
@@ -188,9 +190,9 @@ export async function getRepayWithCollIxs<QuoteResponse>({
   repayAmount,
   isClosingPosition,
   budgetAndPriorityFeeIxs,
-  collTokenMint,
+  collReserveAddress,
   currentSlot,
-  debtTokenMint,
+  debtReserveAddress,
   kaminoMarket,
   owner,
   obligation,
@@ -202,9 +204,9 @@ export async function getRepayWithCollIxs<QuoteResponse>({
   logger = console.log,
 }: RepayWithCollIxsProps<QuoteResponse>): Promise<Array<RepayWithCollIxsResponse<QuoteResponse>>> {
   const { swapInputs, initialInputs } = await getRepayWithCollSwapInputs({
-    collTokenMint,
+    collReserveAddress,
     currentSlot,
-    debtTokenMint,
+    debtReserveAddress,
     kaminoMarket,
     owner,
     obligation,
@@ -219,8 +221,8 @@ export async function getRepayWithCollIxs<QuoteResponse>({
   const { debtRepayAmountLamports, flashRepayAmountLamports, maxCollateralWithdrawLamports, swapQuote } = initialInputs;
   const { inputAmountLamports: collSwapInLamports } = swapInputs;
 
-  const collReserve = kaminoMarket.getExistingReserveByMint(collTokenMint);
-  const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
+  const collReserve = kaminoMarket.getExistingReserveByAddress(collReserveAddress);
+  const debtReserve = kaminoMarket.getExistingReserveByAddress(debtReserveAddress);
 
   // the client should use these values to prevent this input, but the tx may succeed, so we don't want to fail
   // there is also a chance that the tx will consume debt token from the user's ata which they would not expect
@@ -328,40 +330,40 @@ async function buildRepayWithCollateralIxs<QuoteResponse>(
   // 3. Repay using the flash borrowed funds & withdraw collateral to swap and pay the flash loan
   let repayAndWithdrawAction;
   if (maxWithdrawLtvCheck === MaxWithdrawLtvCheck.MAX_LTV) {
-    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawTxns(
-      market,
-      isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
-      debtReserve.getLiquidityMint(),
-      isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
-      collReserve.getLiquidityMint(),
-      owner,
+    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawTxns({
+      kaminoMarket: market,
+      repayAmount: isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
+      repayReserveAddress: debtReserve.address,
+      withdrawAmount: isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
+      withdrawReserveAddress: collReserve.address,
+      payer: owner,
       currentSlot,
       obligation,
       useV2Ixs,
-      undefined,
-      0,
-      false,
+      scopeRefreshConfig: undefined,
+      extraComputeBudget: 0,
+      includeAtaIxs: false,
       requestElevationGroup,
-      undefined,
-      referrer
-    );
+      initUserMetadata: undefined,
+      referrer,
+    });
   } else {
-    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawV2Txns(
-      market,
-      isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
-      debtReserve.getLiquidityMint(),
-      isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
-      collReserve.getLiquidityMint(),
-      owner,
+    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawV2Txns({
+      kaminoMarket: market,
+      repayAmount: isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
+      repayReserveAddress: debtReserve.address,
+      withdrawAmount: isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
+      withdrawReserveAddress: collReserve.address,
+      payer: owner,
       currentSlot,
       obligation,
-      undefined,
-      0,
-      false,
+      scopeRefreshConfig: undefined,
+      extraComputeBudget: 0,
+      includeAtaIxs: false,
       requestElevationGroup,
-      undefined,
-      referrer
-    );
+      initUserMetadata: undefined,
+      referrer,
+    });
   }
 
   // 4. Swap collateral to debt to repay flash loan

package/src/lending_operations/swap_collateral_operations.ts

@@ -40,14 +40,14 @@ export interface SwapCollIxsInputs<QuoteResponse> {
   isClosingSourceColl: boolean;
 
   /**
-   * The mint of the source collateral token (i.e. the current one).
+   * The address of the source collateral reserve (i.e. the current one).
    */
-  sourceCollTokenMint: Address;
+  sourceCollReserveAddress: Address;
 
   /**
-   * The mint of the target collateral token (i.e. the new one).
+   * The address of the target collateral reserve (i.e. the new one).
    */
-  targetCollTokenMint: Address;
+  targetCollReserveAddress: Address;
 
   /**
    * An elevation group ID that the obligation should end up with after the collateral swap - it will be requested by
@@ -220,7 +220,7 @@ type SwapCollContext<QuoteResponse> = {
 function extractArgsAndContext<QuoteResponse>(
   inputs: SwapCollIxsInputs<QuoteResponse>
 ): [SwapCollArgs, SwapCollContext<QuoteResponse>] {
-  if (inputs.sourceCollTokenMint === inputs.targetCollTokenMint) {
+  if (inputs.sourceCollReserveAddress === inputs.targetCollReserveAddress) {
     throw new Error(`Cannot swap from/to the same collateral`);
   }
   if (inputs.sourceCollSwapAmount.lte(0)) {
@@ -235,8 +235,14 @@ function extractArgsAndContext<QuoteResponse>(
     {
       budgetAndPriorityFeeIxs:
         inputs.budgetAndPriorityFeeIxs || getComputeBudgetAndPriorityFeeIxs(DEFAULT_MAX_COMPUTE_UNITS),
-      sourceCollReserve: inputs.market.getExistingReserveByMint(inputs.sourceCollTokenMint, 'Current collateral'),
-      targetCollReserve: inputs.market.getExistingReserveByMint(inputs.targetCollTokenMint, 'Target collateral'),
+      sourceCollReserve: inputs.market.getExistingReserveByAddress(
+        inputs.sourceCollReserveAddress,
+        'Current collateral'
+      ),
+      targetCollReserve: inputs.market.getExistingReserveByAddress(
+        inputs.targetCollReserveAddress,
+        'Target collateral'
+      ),
       logger: console.log,
       market: inputs.market,
       obligation: inputs.obligation,
@@ -395,22 +401,22 @@ async function getDepositTargetCollIxs(
   context: SwapCollContext<any>
 ): Promise<DepositTargetCollIxs> {
   const removesElevationGroup = mustRemoveElevationGroupBeforeDeposit(context);
-  const depositCollAction = await KaminoAction.buildDepositTxns(
-    context.market,
-    targetCollAmount.mul(context.targetCollReserve.getMintFactor()).toString(), // in lamports
-    context.targetCollReserve.getLiquidityMint(),
-    context.owner,
-    context.obligation,
-    context.useV2Ixs,
-    undefined, // we create the scope refresh ix outside of KaminoAction
-    0, // no extra compute budget
-    false, // we do not need ATA ixs here (we construct and close them ourselves)
-    removesElevationGroup, // we may need to (temporarily) remove the elevation group; the same or a different one will be set on withdraw, if requested
-    { skipInitialization: true, skipLutCreation: true }, // we are dealing with an existing obligation, no need to create user metadata
-    context.referrer,
-    context.currentSlot,
-    removesElevationGroup ? 0 : undefined // only applicable when removing the group
-  );
+  const depositCollAction = await KaminoAction.buildDepositTxns({
+    kaminoMarket: context.market,
+    amount: targetCollAmount.mul(context.targetCollReserve.getMintFactor()).toString(), // in lamports
+    reserveAddress: context.targetCollReserve.address,
+    owner: context.owner,
+    obligation: context.obligation,
+    useV2Ixs: context.useV2Ixs,
+    scopeRefreshConfig: undefined, // we create the scope refresh ix outside of KaminoAction
+    extraComputeBudget: 0, // no extra compute budget
+    includeAtaIxs: false, // we do not need ATA ixs here (we construct and close them ourselves)
+    requestElevationGroup: removesElevationGroup, // we may need to (temporarily) remove the elevation group; the same or a different one will be set on withdraw, if requested
+    initUserMetadata: { skipInitialization: true, skipLutCreation: true }, // we are dealing with an existing obligation, no need to create user metadata
+    referrer: context.referrer,
+    currentSlot: context.currentSlot,
+    overrideElevationGroupRequest: removesElevationGroup ? 0 : undefined, // only applicable when removing the group
+  });
   return {
     ixs: KaminoAction.actionToIxs(depositCollAction),
     removesElevationGroup,
@@ -444,27 +450,27 @@ async function getWithdrawSourceCollIxs(
     ? U64_MAX
     : args.sourceCollSwapAmount.mul(context.sourceCollReserve.getMintFactor()).toString();
   const requestedElevationGroup = elevationGroupIdToRequestAfterWithdraw(args, depositRemovedElevationGroup, context);
-  const withdrawCollAction = await KaminoAction.buildWithdrawTxns(
-    context.market,
-    withdrawnSourceCollLamports,
-    context.sourceCollReserve.getLiquidityMint(),
-    context.owner,
-    context.obligation,
-    context.useV2Ixs,
-    undefined, // we create the scope refresh ix outside of KaminoAction
-    0, // no extra compute budget
-    false, // we do not need ATA ixs here (we construct and close them ourselves)
-    requestedElevationGroup !== undefined, // the `elevationGroupIdToRequestAfterWithdraw()` has already decided on this
-    { skipInitialization: true, skipLutCreation: true }, // we are dealing with an existing obligation, no need to create user metadata
-    context.referrer,
-    context.currentSlot,
-    requestedElevationGroup,
-    context.obligation.deposits.has(context.targetCollReserve.address) // if our obligation already had the target coll...
+  const withdrawCollAction = await KaminoAction.buildWithdrawTxns({
+    kaminoMarket: context.market,
+    amount: withdrawnSourceCollLamports,
+    reserveAddress: context.sourceCollReserve.address,
+    owner: context.owner,
+    obligation: context.obligation,
+    useV2Ixs: context.useV2Ixs,
+    scopeRefreshConfig: undefined, // we create the scope refresh ix outside of KaminoAction
+    extraComputeBudget: 0, // no extra compute budget
+    includeAtaIxs: false, // we do not need ATA ixs here (we construct and close them ourselves)
+    requestElevationGroup: requestedElevationGroup !== undefined, // the `elevationGroupIdToRequestAfterWithdraw()` has already decided on this
+    initUserMetadata: { skipInitialization: true, skipLutCreation: true }, // we are dealing with an existing obligation, no need to create user metadata
+    referrer: context.referrer,
+    currentSlot: context.currentSlot,
+    overrideElevationGroupRequest: requestedElevationGroup,
+    obligationCustomizations: context.obligation.deposits.has(context.targetCollReserve.address) // if our obligation already had the target coll...
       ? undefined // ... then we need no customizations here, but otherwise...
       : {
           addedDepositReserves: [context.targetCollReserve.address], // ... we need to inform our infra that the obligation now has one more reserve that needs refreshing.
-        }
-  );
+        },
+  });
   return KaminoAction.actionToIxs(withdrawCollAction);
 }