@kamino-finance/klend-sdk 3.2.26 → 4.0.0

package/src/idl_codegen_kamino_vault/types/VaultAllocation.ts

@@ -0,0 +1,115 @@
+import { PublicKey } from '@solana/web3.js'; // 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';
+
+export interface VaultAllocationFields {
+  reserve: PublicKey;
+  targetAllocationWeight: BN;
+  /** Maximum token invested in this reserve */
+  tokenAllocationCap: BN;
+  configPadding: Array<BN>;
+  cTokenAllocation: BN;
+  tokenTargetAllocation: BN;
+  statePadding: Array<BN>;
+}
+
+export interface VaultAllocationJSON {
+  reserve: string;
+  targetAllocationWeight: string;
+  /** Maximum token invested in this reserve */
+  tokenAllocationCap: string;
+  configPadding: Array<string>;
+  cTokenAllocation: string;
+  tokenTargetAllocation: string;
+  statePadding: Array<string>;
+}
+
+export class VaultAllocation {
+  readonly reserve: PublicKey;
+  readonly targetAllocationWeight: BN;
+  /** Maximum token invested in this reserve */
+  readonly tokenAllocationCap: BN;
+  readonly configPadding: Array<BN>;
+  readonly cTokenAllocation: BN;
+  readonly tokenTargetAllocation: BN;
+  readonly statePadding: Array<BN>;
+
+  constructor(fields: VaultAllocationFields) {
+    this.reserve = fields.reserve;
+    this.targetAllocationWeight = fields.targetAllocationWeight;
+    this.tokenAllocationCap = fields.tokenAllocationCap;
+    this.configPadding = fields.configPadding;
+    this.cTokenAllocation = fields.cTokenAllocation;
+    this.tokenTargetAllocation = fields.tokenTargetAllocation;
+    this.statePadding = fields.statePadding;
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.publicKey('reserve'),
+        borsh.u64('targetAllocationWeight'),
+        borsh.u64('tokenAllocationCap'),
+        borsh.array(borsh.u128(), 64, 'configPadding'),
+        borsh.u64('cTokenAllocation'),
+        borsh.u64('tokenTargetAllocation'),
+        borsh.array(borsh.u128(), 64, 'statePadding'),
+      ],
+      property
+    );
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new VaultAllocation({
+      reserve: obj.reserve,
+      targetAllocationWeight: obj.targetAllocationWeight,
+      tokenAllocationCap: obj.tokenAllocationCap,
+      configPadding: obj.configPadding,
+      cTokenAllocation: obj.cTokenAllocation,
+      tokenTargetAllocation: obj.tokenTargetAllocation,
+      statePadding: obj.statePadding,
+    });
+  }
+
+  static toEncodable(fields: VaultAllocationFields) {
+    return {
+      reserve: fields.reserve,
+      targetAllocationWeight: fields.targetAllocationWeight,
+      tokenAllocationCap: fields.tokenAllocationCap,
+      configPadding: fields.configPadding,
+      cTokenAllocation: fields.cTokenAllocation,
+      tokenTargetAllocation: fields.tokenTargetAllocation,
+      statePadding: fields.statePadding,
+    };
+  }
+
+  toJSON(): VaultAllocationJSON {
+    return {
+      reserve: this.reserve.toString(),
+      targetAllocationWeight: this.targetAllocationWeight.toString(),
+      tokenAllocationCap: this.tokenAllocationCap.toString(),
+      configPadding: this.configPadding.map((item) => item.toString()),
+      cTokenAllocation: this.cTokenAllocation.toString(),
+      tokenTargetAllocation: this.tokenTargetAllocation.toString(),
+      statePadding: this.statePadding.map((item) => item.toString()),
+    };
+  }
+
+  static fromJSON(obj: VaultAllocationJSON): VaultAllocation {
+    return new VaultAllocation({
+      reserve: new PublicKey(obj.reserve),
+      targetAllocationWeight: new BN(obj.targetAllocationWeight),
+      tokenAllocationCap: new BN(obj.tokenAllocationCap),
+      configPadding: obj.configPadding.map((item) => new BN(item)),
+      cTokenAllocation: new BN(obj.cTokenAllocation),
+      tokenTargetAllocation: new BN(obj.tokenTargetAllocation),
+      statePadding: obj.statePadding.map((item) => new BN(item)),
+    });
+  }
+
+  toEncodable() {
+    return VaultAllocation.toEncodable(this);
+  }
+}

package/src/idl_codegen_kamino_vault/types/WithdrawalCaps.ts

@@ -0,0 +1,86 @@
+import { PublicKey } from '@solana/web3.js'; // 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';
+
+export interface WithdrawalCapsFields {
+  configCapacity: BN;
+  currentTotal: BN;
+  lastIntervalStartTimestamp: BN;
+  configIntervalLengthSeconds: BN;
+}
+
+export interface WithdrawalCapsJSON {
+  configCapacity: string;
+  currentTotal: string;
+  lastIntervalStartTimestamp: string;
+  configIntervalLengthSeconds: string;
+}
+
+/** Reserve Withdrawal Caps State */
+export class WithdrawalCaps {
+  readonly configCapacity: BN;
+  readonly currentTotal: BN;
+  readonly lastIntervalStartTimestamp: BN;
+  readonly configIntervalLengthSeconds: BN;
+
+  constructor(fields: WithdrawalCapsFields) {
+    this.configCapacity = fields.configCapacity;
+    this.currentTotal = fields.currentTotal;
+    this.lastIntervalStartTimestamp = fields.lastIntervalStartTimestamp;
+    this.configIntervalLengthSeconds = fields.configIntervalLengthSeconds;
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.i64('configCapacity'),
+        borsh.i64('currentTotal'),
+        borsh.u64('lastIntervalStartTimestamp'),
+        borsh.u64('configIntervalLengthSeconds'),
+      ],
+      property
+    );
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new WithdrawalCaps({
+      configCapacity: obj.configCapacity,
+      currentTotal: obj.currentTotal,
+      lastIntervalStartTimestamp: obj.lastIntervalStartTimestamp,
+      configIntervalLengthSeconds: obj.configIntervalLengthSeconds,
+    });
+  }
+
+  static toEncodable(fields: WithdrawalCapsFields) {
+    return {
+      configCapacity: fields.configCapacity,
+      currentTotal: fields.currentTotal,
+      lastIntervalStartTimestamp: fields.lastIntervalStartTimestamp,
+      configIntervalLengthSeconds: fields.configIntervalLengthSeconds,
+    };
+  }
+
+  toJSON(): WithdrawalCapsJSON {
+    return {
+      configCapacity: this.configCapacity.toString(),
+      currentTotal: this.currentTotal.toString(),
+      lastIntervalStartTimestamp: this.lastIntervalStartTimestamp.toString(),
+      configIntervalLengthSeconds: this.configIntervalLengthSeconds.toString(),
+    };
+  }
+
+  static fromJSON(obj: WithdrawalCapsJSON): WithdrawalCaps {
+    return new WithdrawalCaps({
+      configCapacity: new BN(obj.configCapacity),
+      currentTotal: new BN(obj.currentTotal),
+      lastIntervalStartTimestamp: new BN(obj.lastIntervalStartTimestamp),
+      configIntervalLengthSeconds: new BN(obj.configIntervalLengthSeconds),
+    });
+  }
+
+  toEncodable() {
+    return WithdrawalCaps.toEncodable(this);
+  }
+}

package/src/idl_codegen_kamino_vault/types/index.ts

@@ -0,0 +1,30 @@
+export { LastUpdate } from './LastUpdate';
+export type { LastUpdateFields, LastUpdateJSON } from './LastUpdate';
+export { BigFractionBytes } from './BigFractionBytes';
+export type { BigFractionBytesFields, BigFractionBytesJSON } from './BigFractionBytes';
+export { ReserveCollateral } from './ReserveCollateral';
+export type { ReserveCollateralFields, ReserveCollateralJSON } from './ReserveCollateral';
+export { ReserveConfig } from './ReserveConfig';
+export type { ReserveConfigFields, ReserveConfigJSON } from './ReserveConfig';
+export { ReserveFees } from './ReserveFees';
+export type { ReserveFeesFields, ReserveFeesJSON } from './ReserveFees';
+export { ReserveLiquidity } from './ReserveLiquidity';
+export type { ReserveLiquidityFields, ReserveLiquidityJSON } from './ReserveLiquidity';
+export { WithdrawalCaps } from './WithdrawalCaps';
+export type { WithdrawalCapsFields, WithdrawalCapsJSON } from './WithdrawalCaps';
+export { PriceHeuristic } from './PriceHeuristic';
+export type { PriceHeuristicFields, PriceHeuristicJSON } from './PriceHeuristic';
+export { PythConfiguration } from './PythConfiguration';
+export type { PythConfigurationFields, PythConfigurationJSON } from './PythConfiguration';
+export { ScopeConfiguration } from './ScopeConfiguration';
+export type { ScopeConfigurationFields, ScopeConfigurationJSON } from './ScopeConfiguration';
+export { SwitchboardConfiguration } from './SwitchboardConfiguration';
+export type { SwitchboardConfigurationFields, SwitchboardConfigurationJSON } from './SwitchboardConfiguration';
+export { TokenInfo } from './TokenInfo';
+export type { TokenInfoFields, TokenInfoJSON } from './TokenInfo';
+export { BorrowRateCurve } from './BorrowRateCurve';
+export type { BorrowRateCurveFields, BorrowRateCurveJSON } from './BorrowRateCurve';
+export { CurvePoint } from './CurvePoint';
+export type { CurvePointFields, CurvePointJSON } from './CurvePoint';
+export { VaultAllocation } from './VaultAllocation';
+export type { VaultAllocationFields, VaultAllocationJSON } from './VaultAllocation';

package/src/index.ts

@@ -0,0 +1 @@
+export * from './lib';

package/src/lending_operations/index.ts

@@ -0,0 +1,2 @@
+export * from './repay_with_collateral_operations';
+export * from './repay_with_collateral_calcs';

package/src/lending_operations/repay_with_collateral_calcs.ts

@@ -0,0 +1,71 @@
+import Decimal from 'decimal.js';
+import { KaminoMarket, KaminoObligation } from '../classes';
+import { PublicKey } from '@solana/web3.js';
+
+export function estimateDebtRepaymentWithColl(props: {
+  collAmount: Decimal; // in decimals
+  priceDebtToColl: Decimal;
+  slippagePct: Decimal;
+  flashBorrowReserveFlashLoanFeePercentage: Decimal;
+  kaminoMarket: KaminoMarket;
+  debtTokenMint: PublicKey;
+  obligation: KaminoObligation;
+  currentSlot: number;
+}): Decimal {
+  const {
+    collAmount,
+    priceDebtToColl,
+    slippagePct,
+    flashBorrowReserveFlashLoanFeePercentage,
+    kaminoMarket,
+    debtTokenMint,
+    obligation,
+    currentSlot,
+  } = props;
+  const slippage = slippagePct.div('100');
+  const flashLoanFee = flashBorrowReserveFlashLoanFeePercentage.div('100');
+  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
+  if (debtReserve === undefined) {
+    throw new Error('Debt reserve not found');
+  }
+
+  const debtAfterSwap = collAmount.div(new Decimal(1.0).add(slippage)).div(priceDebtToColl);
+  const debtAfterFlashLoanRepay = debtAfterSwap.div(new Decimal(1.0).add(flashLoanFee));
+
+  const irSlippageBpsForDebt = obligation
+    .estimateObligationInterestRate(
+      kaminoMarket,
+      debtReserve,
+      obligation?.state.borrows.find((borrow) => borrow.borrowReserve?.equals(debtReserve.address))!,
+      currentSlot
+    )
+    .toDecimalPlaces(debtReserve.state.liquidity.mintDecimals.toNumber(), Decimal.ROUND_CEIL);
+
+  // Estimate slightly more, by adding 1% to IR in order to avoid the case where UI users can repay the max we allow them
+  const debtIrAdjusted = debtAfterFlashLoanRepay
+    .div(irSlippageBpsForDebt.mul(new Decimal('1.01')))
+    .toDecimalPlaces(debtReserve.state.liquidity.mintDecimals.toNumber(), Decimal.ROUND_CEIL);
+
+  return debtIrAdjusted;
+}
+
+export function estimateCollNeededForDebtRepayment(props: {
+  debtAmount: Decimal; // in decimals
+  priceDebtToColl: Decimal;
+  slippagePct: Decimal;
+  flashBorrowReserveFlashLoanFeePercentage: Decimal;
+}): Decimal {
+  const {
+    debtAmount, // in decimals
+    priceDebtToColl,
+    slippagePct,
+    flashBorrowReserveFlashLoanFeePercentage,
+  } = props;
+  const slippage = slippagePct.div('100');
+  const flashLoanFee = flashBorrowReserveFlashLoanFeePercentage.div('100');
+
+  const debtFlashLoanRepay = debtAmount.mul(new Decimal(1.0).add(flashLoanFee));
+  const collToSwap = debtFlashLoanRepay.mul(new Decimal(1.0).add(slippage)).mul(priceDebtToColl);
+
+  return collToSwap;
+}

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -0,0 +1,318 @@
+import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { KaminoAction, KaminoMarket, KaminoObligation, numberToLamportsDecimal } from '../classes';
+import { SwapInputs, SwapIxnsProvider, getFlashLoanInstructions, toJson } from '../leverage';
+import {
+  PublicKeySet,
+  ScopeRefresh,
+  U64_MAX,
+  getAtasWithCreateIxnsIfMissing,
+  getComputeBudgetAndPriorityFeeIxns,
+  removeBudgetAndAtaIxns,
+} from '../utils';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+import Decimal from 'decimal.js';
+
+export const repayWithCollCalcs = (props: {
+  repayAmount: Decimal;
+  priceDebtToColl: Decimal;
+  slippagePct: Decimal;
+  flashLoanFeePct: Decimal;
+}): {
+  repayAmount: Decimal;
+  collToSwapIn: Decimal;
+  swapDebtExpectedOut: Decimal;
+} => {
+  // Initialize local variables from the props object
+  const { repayAmount, priceDebtToColl, slippagePct, flashLoanFeePct } = props;
+
+  const slippage = slippagePct.div('100');
+  const flashLoanFee = flashLoanFeePct.div('100');
+
+  const swapDebtExpectedOut = repayAmount.mul(new Decimal(1.0).add(flashLoanFee));
+  const collToSwapIn = swapDebtExpectedOut.mul(new Decimal(1.0).add(slippage)).mul(priceDebtToColl);
+
+  return {
+    repayAmount,
+    collToSwapIn,
+    swapDebtExpectedOut,
+  };
+};
+
+export type InitialInputs = {
+  repayAmount: Decimal;
+  priceDebtToColl: Decimal;
+  slippagePct: Decimal;
+  currentSlot: number;
+};
+
+export const getRepayWithCollSwapInputs = (props: {
+  repayAmount: Decimal;
+  priceDebtToColl: Decimal;
+  slippagePct: Decimal;
+  kaminoMarket: KaminoMarket;
+  debtTokenMint: PublicKey;
+  collTokenMint: PublicKey;
+  obligation: KaminoObligation;
+  currentSlot: number;
+}): {
+  swapInputs: SwapInputs;
+  initialInputs: InitialInputs;
+} => {
+  const {
+    repayAmount,
+    priceDebtToColl,
+    slippagePct,
+    kaminoMarket,
+    debtTokenMint,
+    collTokenMint,
+    obligation,
+    currentSlot,
+  } = props;
+  const collReserve = kaminoMarket.getReserveByMint(collTokenMint);
+  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
+  const flashLoanFeePct = debtReserve?.getFlashLoanFee().ceil() || new Decimal(0);
+
+  const irSlippageBpsForDebt = obligation!
+    .estimateObligationInterestRate(
+      kaminoMarket,
+      debtReserve!,
+      obligation?.state.borrows.find((borrow) => borrow.borrowReserve?.equals(debtReserve!.address))!,
+      currentSlot
+    )
+    .toDecimalPlaces(debtReserve?.state.liquidity.mintDecimals.toNumber()!, Decimal.ROUND_CEIL);
+  // add 0.1% to irSlippageBpsForDebt because we don't want to estimate slightly less than SC and end up not repaying enough
+  const repayAmountIrAdjusted = repayAmount
+    .mul(irSlippageBpsForDebt.mul(new Decimal('1.001')))
+    .toDecimalPlaces(debtReserve?.state.liquidity.mintDecimals.toNumber()!, Decimal.ROUND_CEIL);
+
+  const repayCalcs = repayWithCollCalcs({
+    repayAmount: repayAmountIrAdjusted,
+    priceDebtToColl,
+    slippagePct,
+    flashLoanFeePct: flashLoanFeePct,
+  });
+
+  return {
+    swapInputs: {
+      inputAmountLamports: numberToLamportsDecimal(repayCalcs.collToSwapIn, collReserve!.stats.decimals)
+        .ceil()
+        .toNumber(),
+      inputMint: collTokenMint,
+      outputMint: debtTokenMint,
+    },
+    initialInputs: {
+      repayAmount,
+      priceDebtToColl,
+      slippagePct,
+      currentSlot,
+    },
+  };
+};
+
+export const getRepayWithCollIxns = async (props: {
+  kaminoMarket: KaminoMarket;
+  budgetAndPriorityFeeIxns: TransactionInstruction[];
+  amount: Decimal;
+  debtTokenMint: PublicKey;
+  collTokenMint: PublicKey;
+  owner: PublicKey;
+  priceDebtToColl: Decimal;
+  slippagePct: Decimal;
+  isClosingPosition: boolean;
+  obligation: KaminoObligation;
+  referrer: PublicKey;
+  swapper: SwapIxnsProvider;
+  currentSlot: number;
+  getTotalKlendAccountsOnly: boolean;
+  scopeRefresh: ScopeRefresh;
+}): Promise<{
+  ixns: TransactionInstruction[];
+  lookupTablesAddresses: PublicKey[];
+  swapInputs: SwapInputs;
+  totalKlendAccounts: number;
+  initialInputs: InitialInputs;
+}> => {
+  const {
+    kaminoMarket,
+    budgetAndPriorityFeeIxns,
+    amount,
+    debtTokenMint,
+    collTokenMint,
+    owner,
+    priceDebtToColl,
+    slippagePct,
+    isClosingPosition,
+    obligation,
+    referrer,
+    swapper,
+    currentSlot,
+    getTotalKlendAccountsOnly,
+    scopeRefresh,
+  } = props;
+
+  const connection = kaminoMarket.getConnection();
+  const collReserve = kaminoMarket.getReserveByMint(collTokenMint);
+  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
+  // const solTokenReserve = kaminoMarket.getReserveByMint(WRAPPED_SOL_MINT);
+  const flashLoanFeePct = debtReserve?.getFlashLoanFee() || new Decimal(0);
+
+  const irSlippageBpsForDebt = obligation!
+    .estimateObligationInterestRate(
+      kaminoMarket,
+      debtReserve!,
+      obligation?.state.borrows.find((borrow) => borrow.borrowReserve?.equals(debtReserve!.address))!,
+      currentSlot
+    )
+    .toDecimalPlaces(debtReserve?.state.liquidity.mintDecimals.toNumber()!, Decimal.ROUND_CEIL);
+  // add 0.1% to irSlippageBpsForDebt because we don't want to estimate slightly less than SC and end up not reapying enough
+  const repayAmount = amount
+    .mul(irSlippageBpsForDebt.mul(new Decimal('1.001')))
+    .toDecimalPlaces(debtReserve?.state.liquidity.mintDecimals.toNumber()!, Decimal.ROUND_CEIL);
+
+  const calcs = repayWithCollCalcs({
+    repayAmount,
+    priceDebtToColl,
+    slippagePct,
+    flashLoanFeePct,
+  });
+
+  console.log('Ops Calcs', toJson(calcs));
+
+  // // 1. Create atas & budget txns
+  const mintsToCreateAtas = [collTokenMint, debtTokenMint, collReserve!.getCTokenMint()];
+  const mintsToCreateAtasTokenPrograms = [
+    collReserve?.getLiquidityTokenProgram()!,
+    debtReserve?.getLiquidityTokenProgram()!,
+    TOKEN_PROGRAM_ID,
+  ];
+
+  const budgetIxns = budgetAndPriorityFeeIxns || getComputeBudgetAndPriorityFeeIxns(3000000);
+  const {
+    atas: [, debtTokenAta],
+    createAtasIxns,
+    closeAtasIxns,
+  } = await getAtasWithCreateIxnsIfMissing(connection, owner, mintsToCreateAtas, mintsToCreateAtasTokenPrograms);
+
+  // 1. Flash borrow & repay the debt to repay amount needed
+  const { flashBorrowIxn, flashRepayIxn } = getFlashLoanInstructions({
+    borrowIxnIndex: budgetIxns.length + createAtasIxns.length,
+    walletPublicKey: owner,
+    lendingMarketAuthority: kaminoMarket.getLendingMarketAuthority(),
+    lendingMarketAddress: kaminoMarket.getAddress(),
+    reserve: debtReserve!,
+    amountLamports: numberToLamportsDecimal(repayAmount, debtReserve!.stats.decimals).floor(),
+    destinationAta: debtTokenAta,
+    referrerAccount: kaminoMarket.programId,
+    referrerTokenState: kaminoMarket.programId,
+    programId: kaminoMarket.programId,
+  });
+
+  const requestElevationGroup = obligation.state.elevationGroup !== 0 ? true : false;
+
+  // 2. Repay using the flash borrowed funds & withdraw collateral to swap and pay the flash loan
+  const repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawTxns(
+    kaminoMarket,
+    isClosingPosition ? U64_MAX : numberToLamportsDecimal(repayAmount, debtReserve!.stats.decimals).floor().toString(),
+    new PublicKey(debtTokenMint),
+    isClosingPosition
+      ? U64_MAX
+      : numberToLamportsDecimal(calcs.collToSwapIn, collReserve!.stats.decimals).ceil().toString(),
+    new PublicKey(collTokenMint),
+    owner,
+    currentSlot,
+    obligation,
+    0,
+    false,
+    requestElevationGroup,
+    undefined,
+    isClosingPosition,
+    referrer,
+    scopeRefresh
+  );
+
+  const ixns = [
+    ...budgetIxns,
+    ...createAtasIxns,
+    ...[flashBorrowIxn],
+    ...repayAndWithdrawAction.setupIxs,
+    ...[repayAndWithdrawAction.lendingIxs[0]],
+    ...repayAndWithdrawAction.inBetweenIxs,
+    ...[repayAndWithdrawAction.lendingIxs[1]],
+    ...repayAndWithdrawAction.cleanupIxs,
+    ...[flashRepayIxn],
+    ...closeAtasIxns,
+  ];
+
+  const uniqueAccounts = new PublicKeySet<PublicKey>([]);
+  ixns.forEach((ixn) => {
+    ixn.keys.forEach((key) => {
+      uniqueAccounts.add(key.pubkey);
+    });
+  });
+  const totalKlendAccounts = uniqueAccounts.toArray().length;
+
+  // return early to avoid extra swapper calls
+  if (getTotalKlendAccountsOnly) {
+    return {
+      ixns: [],
+      lookupTablesAddresses: [],
+      swapInputs: { inputAmountLamports: 0, inputMint: PublicKey.default, outputMint: PublicKey.default },
+      totalKlendAccounts: totalKlendAccounts,
+      initialInputs: {
+        repayAmount,
+        priceDebtToColl,
+        slippagePct,
+        currentSlot,
+      },
+    };
+  }
+
+  console.log(
+    'Expected to swap in',
+    calcs.collToSwapIn.toString(),
+    'coll for',
+    calcs.swapDebtExpectedOut.toString(),
+    'debt'
+  );
+
+  const swapInputs: SwapInputs = {
+    inputAmountLamports: numberToLamportsDecimal(calcs.collToSwapIn, collReserve!.stats.decimals).ceil().toNumber(),
+    inputMint: collTokenMint,
+    outputMint: debtTokenMint,
+  };
+
+  // 3. Swap collateral to debt to repay flash loan
+  const [swapIxns, lookupTablesAddresses] = await swapper(
+    swapInputs.inputAmountLamports,
+    swapInputs.inputMint,
+    swapInputs.outputMint,
+    slippagePct.toNumber()
+  );
+
+  const swapInstructions = removeBudgetAndAtaIxns(swapIxns, []);
+
+  return {
+    ixns: [
+      ...budgetIxns,
+      ...createAtasIxns,
+      ...[flashBorrowIxn],
+      ...repayAndWithdrawAction.setupIxs,
+      ...[repayAndWithdrawAction.lendingIxs[0]],
+      ...repayAndWithdrawAction.inBetweenIxs,
+      ...[repayAndWithdrawAction.lendingIxs[1]],
+      ...repayAndWithdrawAction.cleanupIxs,
+      ...swapInstructions,
+      ...[flashRepayIxn],
+      ...closeAtasIxns,
+    ],
+    lookupTablesAddresses,
+    swapInputs,
+    totalKlendAccounts,
+    initialInputs: {
+      repayAmount,
+      priceDebtToColl,
+      slippagePct,
+      currentSlot,
+    },
+  };
+};