@kamino-finance/klend-sdk 5.2.12 → 5.2.14

package/src/client_kamino_manager.ts

@@ -26,6 +26,7 @@ import {
   ReserveAllocationConfig,
   ReserveWithAddress,
   signSendAndConfirmRawTransactionWithRetry,
+  sleep,
   Web3Client,
 } from './lib';
 import * as anchor from '@coral-xyz/anchor';
@@ -52,6 +53,7 @@ import {
   PerformanceFeeBps,
 } from './idl_codegen_kamino_vault/types/VaultConfigField';
 import { getAccountOwner } from './utils/rpc';
+import { Farms, FarmState, getUserStatePDA } from '@kamino-finance/farms-sdk';
 
 dotenv.config({
   path: `.env${process.env.ENV ? '.' + process.env.ENV : ''}`,
@@ -224,9 +226,10 @@ async function main() {
       `--mode <string>`,
       'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage'
     )
+    .option(`--name`, 'The onchain name of the strat')
     .option(`--staging`, 'If true, will use the staging programs')
     .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
-    .action(async ({ mint, mode, staging, multisig }) => {
+    .action(async ({ mint, mode, name, staging, multisig }) => {
       const env = initializeClient(mode === 'multisig', staging);
       const tokenMint = new PublicKey(mint);
 
@@ -244,11 +247,14 @@ async function main() {
         tokenMintProgramId: tokenProgramID,
         performanceFeeRate: new Decimal(0.0),
         managementFeeRate: new Decimal(0.0),
+        name,
       });
 
-      const { vault: vaultKp, ixns: instructions } = await kaminoManager.createVaultIxs(kaminoVaultConfig);
+      const { vault: vaultKp, initVaultIxs: instructions } = await kaminoManager.createVaultIxs(kaminoVaultConfig);
 
-      const _createVaultSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [vaultKp]);
+      const _createVaultSig = await processTxn(env.client, env.payer, instructions.initVaultIxs, mode, 2500, [vaultKp]);
+      await sleep(5000);
+      const _populateLUTSig = await processTxn(env.client, env.payer, instructions.populateLUTIxs, mode, 2500, []);
 
       mode === 'execute' && console.log('Vault created:', vaultKp.publicKey.toBase58());
     });
@@ -274,9 +280,16 @@ async function main() {
       const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
       const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
-      const instruction = await kaminoManager.updateVaultConfigIx(kaminoVault, new PendingVaultAdmin(), newAdmin);
-
-      const updateVaultPendingAdminSig = await processTxn(env.client, env.payer, [instruction], mode, 2500, []);
+      const instructions = await kaminoManager.updateVaultConfigIxs(kaminoVault, new PendingVaultAdmin(), newAdmin);
+
+      const updateVaultPendingAdminSig = await processTxn(
+        env.client,
+        env.payer,
+        [instructions.updateVaultConfigIx, ...instructions.updateLUTIxs],
+        mode,
+        2500,
+        []
+      );
 
       mode === 'execute' && console.log('Pending admin updated:', updateVaultPendingAdminSig);
     });
@@ -302,13 +315,84 @@ async function main() {
       const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
       const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
-      const instruction = await kaminoManager.updateVaultConfigIx(kaminoVault, new ManagementFeeBps(), feeBps);
+      const instructions = await kaminoManager.updateVaultConfigIxs(kaminoVault, new ManagementFeeBps(), feeBps);
+
+      const updateVaultConfigSig = await processTxn(
+        env.client,
+        env.payer,
+        [instructions.updateVaultConfigIx, ...instructions.updateLUTIxs],
+        mode,
+        2500,
+        []
+      );
+
+      mode === 'execute' && console.log('Management fee updated:', updateVaultConfigSig);
+    });
+
+  commands
+    .command('insert-into-lut')
+    .requiredOption('--lut <string>', 'Lookup table address')
+    .requiredOption('--addresses <string>', 'The addresses to insert into the LUT, space separated')
+    .requiredOption(
+      `--mode <string>`,
+      'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage'
+    )
+    .option(`--staging`, 'If true, will use the staging programs')
+    .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+    .action(async ({ lut, addresses, mode, staging, multisig }) => {
+      const env = initializeClient(mode === 'multisig', staging);
+      const lutAddress = new PublicKey(lut);
+
+      const addressesArr = addresses.split(' ').map((address: string) => new PublicKey(address));
+
+      if (mode === 'multisig' && !multisig) {
+        throw new Error('If using multisig mode, multisig is required');
+      }
 
-      const updateVaultConfigSig = await processTxn(env.client, env.payer, [instruction], mode, 2500, []);
+      const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+      const instructions = await kaminoManager.insertIntoLUT(env.payer.publicKey, lutAddress, addressesArr);
+
+      const updateVaultConfigSig = await processTxn(env.client, env.payer, instructions, mode, 2500, []);
 
       mode === 'execute' && console.log('Management fee updated:', updateVaultConfigSig);
     });
 
+  commands
+    .command('sync-vault-lut')
+    .requiredOption('--vault <string>', 'The vault address to sync')
+    .requiredOption(
+      `--mode <string>`,
+      'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage'
+    )
+    .option(`--staging`, 'If true, will use the staging programs')
+    .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+    .action(async ({ vault, mode, staging, multisig }) => {
+      const env = initializeClient(mode === 'multisig', staging);
+      const vaultAddress = new PublicKey(vault);
+
+      if (mode === 'multisig' && !multisig) {
+        throw new Error('If using multisig mode, multisig is required');
+      }
+
+      const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+      const syncLUTIxs = await kaminoManager.syncVaultLUT(kaminoVault);
+
+      // if we need to create the LUT we have to do that in a separate tx and wait a little bit after
+      if (syncLUTIxs.setupLUTIfNeededIxs.length > 0) {
+        const setupLUTSig = await processTxn(env.client, env.payer, syncLUTIxs.setupLUTIfNeededIxs, mode, 2500, []);
+        await sleep(5000);
+        mode === 'execute' && console.log('LUT created and set to the vault:', setupLUTSig);
+      }
+      // if there are accounts to be added to the LUT we have to do that in a separate tx
+      for (const ix of syncLUTIxs.syncLUTIxs) {
+        const insertIntoLUTSig = await processTxn(env.client, env.payer, [ix], mode, 2500, []);
+        mode === 'execute' && console.log('Accounts added to the LUT:', insertIntoLUTSig);
+      }
+    });
+
   commands
     .command('update-vault-perf-fee')
     .requiredOption('--vault <string>', 'Vault address')
@@ -330,9 +414,16 @@ async function main() {
       const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
       const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
-      const instruction = await kaminoManager.updateVaultConfigIx(kaminoVault, new PerformanceFeeBps(), feeBps);
-
-      const updateVaultPerfFeeSig = await processTxn(env.client, env.payer, [instruction], mode, 2500, []);
+      const instructions = await kaminoManager.updateVaultConfigIxs(kaminoVault, new PerformanceFeeBps(), feeBps);
+
+      const updateVaultPerfFeeSig = await processTxn(
+        env.client,
+        env.payer,
+        [instructions.updateVaultConfigIx, ...instructions.updateLUTIxs],
+        mode,
+        2500,
+        []
+      );
 
       mode === 'execute' && console.log('Performance fee updated:', updateVaultPerfFeeSig);
     });
@@ -357,9 +448,16 @@ async function main() {
       const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
       const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
-      const instruction = await kaminoManager.acceptVaultOwnershipIx(kaminoVault);
-
-      const acceptVaultOwnershipSig = await processTxn(env.client, env.payer, [instruction], mode, 2500, []);
+      const instructions = await kaminoManager.acceptVaultOwnershipIxs(kaminoVault);
+
+      const acceptVaultOwnershipSig = await processTxn(
+        env.client,
+        env.payer,
+        [instructions.acceptVaultOwnershipIx, ...instructions.updateLUTIxs],
+        mode,
+        2500,
+        []
+      );
 
       mode === 'execute' && console.log('Vault ownership accepted:', acceptVaultOwnershipSig);
     });
@@ -422,6 +520,56 @@ async function main() {
       mode === 'execute' && console.log('Pending fees withdrawn:', withdrawPendingFeesSig);
     });
 
+  commands
+    .command('stake')
+    .requiredOption('--vault <string>', 'Vault address')
+    .requiredOption('--farm <string>', 'Farm address')
+    .requiredOption('--amount <string>', 'The number of kTokens to stake')
+    .requiredOption(
+      `--mode <string>`,
+      'simulate - to print txn simulation, inspect - to get txn simulation in explorer, execute - execute txn, multisig - to get bs58 txn for multisig usage'
+    )
+    .option(`--staging`, 'If true, will use the staging programs')
+    .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
+    .action(async ({ vault, farm, amount, mode, staging, multisig }) => {
+      const env = initializeClient(mode === 'multisig', staging);
+      const vaultAddress = new PublicKey(vault);
+      const farmAddress = new PublicKey(farm);
+
+      const farmClient = new Farms(env.connection);
+
+      const farmState = await FarmState.fetch(env.connection, farmAddress);
+      const vaultState = await new KaminoVault(vaultAddress, undefined, env.kVaultProgramId).getState(env.connection);
+
+      const scopePricesArg = farmState!.scopePrices.equals(PublicKey.default)
+        ? farmClient.getProgramID()
+        : farmState!.scopePrices;
+
+      const ixns: TransactionInstruction[] = [];
+      const userState = getUserStatePDA(farmClient.getProgramID(), farmAddress, env.provider.publicKey);
+      if (!userState) {
+        const createUserIx = await farmClient.createNewUserIx(env.provider.publicKey, farmAddress);
+        ixns.push(createUserIx);
+      }
+
+      // todo: fix in farms sdk to make this not async
+      const stakeIx = await farmClient.stakeIx(
+        env.payer.publicKey,
+        farmAddress,
+        new Decimal(amount),
+        vaultState.sharesMint,
+        scopePricesArg
+      );
+      ixns.push(stakeIx);
+
+      if (mode === 'multisig' && !multisig) {
+        throw new Error('If using multisig mode, multisig is required');
+      }
+      const withdrawPendingFeesSig = await processTxn(env.client, env.payer, ixns, mode, 2500, []);
+
+      mode === 'execute' && console.log('Pending fees withdrawn:', withdrawPendingFeesSig);
+    });
+
   commands
     .command('update-vault-reserve-allocation')
     .requiredOption('--vault <string>', 'Vault address')
@@ -466,7 +614,14 @@ async function main() {
         firstReserveAllocationConfig
       );
 
-      const updateVaultAllocationSig = await processTxn(env.client, env.payer, [instructions], mode, 2500, []);
+      const updateVaultAllocationSig = await processTxn(
+        env.client,
+        env.payer,
+        [instructions.updateReserveAllocationIx, ...instructions.updateLUTIxs],
+        mode,
+        2500,
+        []
+      );
 
       mode === 'execute' && console.log('Vault allocation updated:', updateVaultAllocationSig);
     });
@@ -557,7 +712,7 @@ async function main() {
       for (let i = 0; i < instructions.length; i++) {
         const txInstructions: TransactionInstruction[] = [];
         txInstructions.push(instructions[i]);
-        const investReserveSig = await processTxn(env.client, env.payer, txInstructions, mode, 2500, [], 400000);
+        const investReserveSig = await processTxn(env.client, env.payer, txInstructions, mode, 2500, [], 800000);
 
         mode === 'execute' && console.log('Reserve invested:', investReserveSig);
       }
@@ -599,7 +754,7 @@ async function main() {
         kaminoVault,
         reserveWithAddress
       );
-      const investReserveSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 400_000);
+      const investReserveSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 800_000);
 
       mode === 'execute' && console.log('Reserve invested:', investReserveSig);
     });
@@ -1059,7 +1214,7 @@ async function processTxn(
       if (simulation.value.logs && simulation.value.logs.length > 0) {
         console.log('Simulation: \n' + simulation.value.logs);
       } else {
-        console.log('Simulation failed: \n' + simulation);
+        console.log('Simulation failed: \n' + simulation.value.err);
       }
     } else if (mode === 'inspect') {
       console.log(
@@ -1076,7 +1231,7 @@ async function processTxn(
 function createAddExtraComputeUnitFeeTransaction(units: number, microLamports: number): TransactionInstruction[] {
   const ixns: TransactionInstruction[] = [];
   ixns.push(ComputeBudgetProgram.setComputeUnitLimit({ units }));
-  ixns.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports }));
+  ixns.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: new Decimal(microLamports).floor().toNumber() }));
   return ixns;
 }
 

package/src/lending_operations/repay_with_collateral_calcs.ts

@@ -76,79 +76,73 @@ export const calcFlashRepayAmount = (props: {
 };
 
 export function calcMaxWithdrawCollateral(
-  kaminoMarket: KaminoMarket,
+  market: KaminoMarket,
+  obligation: KaminoObligation,
   collReserveAddr: PublicKey,
   debtReserveAddr: PublicKey,
-  obligation: KaminoObligation,
   repayAmountLamports: Decimal
 ): {
-  canWithdrawRemainingColl: boolean;
+  repayAmountLamports: Decimal;
   withdrawableCollLamports: Decimal;
+  canWithdrawAllColl: boolean;
+  repayingAllDebt: boolean;
 } {
-  const collReserve = kaminoMarket.getReserveByAddress(collReserveAddr)!;
-  const collOraclePx = collReserve.getOracleMarketPrice();
-  const { maxLtv: collMaxLtv } = obligation.getLtvForReserve(kaminoMarket, collReserve);
-
-  const collPosition = obligation.getDepositByReserve(collReserve.address)!;
-  const initialCollValue = collPosition.amount.floor().div(collReserve.getMintFactor()).mul(collOraclePx);
-
-  let totalRemainingDebtValue = new Decimal(0);
-  const borrows = obligation.getBorrows();
-  for (const debtPosition of borrows) {
-    const debtReserve = kaminoMarket.getReserveByAddress(debtPosition.reserveAddress)!;
-    const debtOraclePx = debtReserve.getOracleMarketPrice();
-    const debtBorrowFactor = debtReserve.getBorrowFactor();
-    let remainingDebtAmountLamports = debtPosition.amount;
-    if (debtPosition.reserveAddress.equals(debtReserveAddr)) {
-      remainingDebtAmountLamports = remainingDebtAmountLamports.sub(repayAmountLamports);
-    }
-    const remainingDebtBfWeightedValue = remainingDebtAmountLamports
-      .ceil()
-      .div(debtReserve.getMintFactor())
-      .mul(debtBorrowFactor)
-      .mul(debtOraclePx);
-    totalRemainingDebtValue = totalRemainingDebtValue.add(remainingDebtBfWeightedValue);
-  }
-
-  let canWithdrawRemainingColl = false;
-  if (totalRemainingDebtValue.lte(new Decimal(0)) && borrows.length === 1) {
-    canWithdrawRemainingColl = true;
+  const deposit = obligation.getDepositByReserve(collReserveAddr)!;
+  const borrow = obligation.getBorrowByReserve(debtReserveAddr)!;
+  const depositReserve = market.getReserveByAddress(deposit.reserveAddress)!;
+  const debtReserve = market.getReserveByAddress(borrow.reserveAddress)!;
+  const depositTotalLamports = deposit.amount.floor();
+
+  const remainingBorrowLamports = borrow.amount.sub(repayAmountLamports).ceil();
+  const remainingBorrowAmount = remainingBorrowLamports.div(debtReserve.getMintFactor());
+  let remainingBorrowsValue = remainingBorrowAmount.mul(debtReserve.getOracleMarketPrice());
+  if (obligation.getBorrows().length > 1) {
+    remainingBorrowsValue = obligation
+      .getBorrows()
+      .filter((p) => !p.reserveAddress.equals(borrow.reserveAddress))
+      .reduce((acc, b) => acc.add(b.marketValueRefreshed), new Decimal('0'));
   }
 
-  const deposits = obligation.getDeposits();
-  const otherCollDeposits = deposits.filter((deposit) => !deposit.reserveAddress.equals(collReserve.address));
-
-  let totalOtherCollateralValue = new Decimal(0);
-  for (const d of otherCollDeposits) {
-    const otherCollReserve = kaminoMarket.getReserveByAddress(d.reserveAddress)!;
-    const otherCollOraclePx = otherCollReserve.getOracleMarketPrice();
-    const otherCollMaxLtv = obligation.getLtvForReserve(kaminoMarket, otherCollReserve).maxLtv;
-    const otherCollValue = d.amount
-      .floor()
-      .div(otherCollReserve.getMintFactor())
-      .mul(otherCollOraclePx)
-      .mul(otherCollMaxLtv);
-    totalOtherCollateralValue = totalOtherCollateralValue.add(otherCollValue);
+  let remainingDepositsValueWithLtv = new Decimal('0');
+  if (obligation.getDeposits().length > 1) {
+    remainingDepositsValueWithLtv = obligation
+      .getDeposits()
+      .filter((p) => !p.reserveAddress.equals(deposit.reserveAddress))
+      .reduce((acc, d) => {
+        const { maxLtv } = obligation.getLtvForReserve(market, market.getReserveByAddress(d.reserveAddress)!);
+        return acc.add(d.marketValueRefreshed.mul(maxLtv));
+      }, new Decimal('0'));
   }
 
-  const numerator = initialCollValue.mul(collMaxLtv).add(totalOtherCollateralValue).sub(totalRemainingDebtValue);
-
-  // If all collateral cannot cover the remaining debt
-  if (numerator.lte('0')) {
-    return { canWithdrawRemainingColl: false, withdrawableCollLamports: new Decimal(0) };
-  }
-
-  const denominator = collOraclePx.mul(collMaxLtv);
-  const maxCollWithdrawAmount = numerator.div(denominator);
-  const maxCollateralWithdrawalAmountLamports = maxCollWithdrawAmount.mul(collReserve.getMintFactor()).floor();
-
-  let withdrawableCollLamports: Decimal;
-  if (canWithdrawRemainingColl) {
-    withdrawableCollLamports = Decimal.min(maxCollateralWithdrawalAmountLamports, collPosition.amount).floor();
+  // can withdraw all coll
+  if (remainingDepositsValueWithLtv.gte(remainingBorrowsValue)) {
+    return {
+      repayAmountLamports: repayAmountLamports,
+      withdrawableCollLamports: depositTotalLamports,
+      canWithdrawAllColl: true,
+      repayingAllDebt: repayAmountLamports.gte(borrow.amount),
+    };
   } else {
-    withdrawableCollLamports = Decimal.max(new Decimal(0), maxCollateralWithdrawalAmountLamports);
+    const { maxLtv: collMaxLtv } = obligation.getLtvForReserve(
+      market,
+      market.getReserveByAddress(depositReserve.address)!
+    );
+    const numerator = deposit.marketValueRefreshed
+      .mul(collMaxLtv)
+      .add(remainingDepositsValueWithLtv)
+      .sub(remainingBorrowsValue);
+
+    const denominator = depositReserve.getOracleMarketPrice().mul(collMaxLtv);
+    const maxCollWithdrawAmount = numerator.div(denominator);
+    const withdrawableCollLamports = maxCollWithdrawAmount.mul(depositReserve.getMintFactor()).floor();
+
+    return {
+      repayAmountLamports: repayAmountLamports,
+      withdrawableCollLamports,
+      canWithdrawAllColl: false,
+      repayingAllDebt: repayAmountLamports.gte(borrow.amount),
+    };
   }
-  return { canWithdrawRemainingColl, withdrawableCollLamports };
 }
 
 export function estimateDebtRepaymentWithColl(props: {

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -29,6 +29,13 @@ export type RepayWithCollIxsResponse<QuoteResponse> = {
 export type InitialInputs<QuoteResponse> = {
   debtRepayAmountLamports: Decimal;
   flashRepayAmountLamports: Decimal;
+  /**
+   * The amount of collateral available to withdraw, if this is less than the swap input amount, then the swap may fail due to slippage, or tokens may be debited from the user's ATA, so the caller needs to check this
+   */
+  maxCollateralWithdrawLamports: Decimal;
+  /**
+   * The quote from the provided quoter
+   */
   swapQuote: SwapQuote<QuoteResponse>;
   currentSlot: number;
   klendAccounts: Array<PublicKey>;
@@ -93,9 +100,9 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
   }
   const { withdrawableCollLamports } = calcMaxWithdrawCollateral(
     kaminoMarket,
+    obligation,
     collReserve.address,
     debtReserve.address,
-    obligation,
     repayAmountLamports
   );
 
@@ -156,6 +163,7 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
     initialInputs: {
       debtRepayAmountLamports: repayAmountLamports,
       flashRepayAmountLamports,
+      maxCollateralWithdrawLamports: withdrawableCollLamports,
       swapQuote,
       currentSlot,
       klendAccounts: uniqueKlendAccounts,
@@ -196,18 +204,30 @@ export async function getRepayWithCollIxs<QuoteResponse>({
     budgetAndPriorityFeeIxs,
     scopeRefresh,
   });
-  const { debtRepayAmountLamports, flashRepayAmountLamports, swapQuote } = initialInputs;
+  const { debtRepayAmountLamports, flashRepayAmountLamports, maxCollateralWithdrawLamports, swapQuote } = initialInputs;
   const { inputAmountLamports: collSwapInLamports } = swapInputs;
 
   const collReserve = kaminoMarket.getReserveByMint(collTokenMint)!;
   const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint)!;
 
+  // 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
+  if (collSwapInLamports.greaterThan(maxCollateralWithdrawLamports)) {
+    logger(
+      `Collateral swap in amount ${collSwapInLamports} exceeds max withdrawable collateral ${maxCollateralWithdrawLamports}, tx may fail with slippage`
+    );
+    swapInputs.inputAmountLamports = maxCollateralWithdrawLamports;
+  }
+
+  const actualSwapInLamports = Decimal.min(collSwapInLamports, maxCollateralWithdrawLamports);
   logger(
-    `Expected to swap in: ${collSwapInLamports.div(collReserve.getMintFactor())} ${
+    `Expected to swap in: ${actualSwapInLamports.div(collReserve.getMintFactor())} ${
       collReserve.symbol
     }, for: ${flashRepayAmountLamports.div(debtReserve.getMintFactor())} ${debtReserve.symbol}, quoter px: ${
       swapQuote.priceAInB
-    } ${debtReserve.symbol}/${collReserve.symbol}`
+    } ${debtReserve.symbol}/${collReserve.symbol}, required px: ${flashRepayAmountLamports
+      .div(debtReserve.getMintFactor())
+      .div(actualSwapInLamports.div(collReserve.getMintFactor()))} ${debtReserve.symbol}/${collReserve.symbol}`
   );
 
   const swapResponse = await swapper(swapInputs, initialInputs.klendAccounts, swapQuote);

package/src/leverage/operations.ts

@@ -1045,7 +1045,7 @@ export async function getAdjustLeverageSwapInputs<QuoteResponse>({
 
     const swapInputAmount = toLamports(
       !collIsKtoken ? calcs.borrowAmount : calcs.amountToFlashBorrowDebt,
-      debtReserve.stats.decimals,
+      debtReserve.stats.decimals
     ).ceil();
 
     const swapInputsForQuote: SwapInputs = {