@kamino-finance/klend-sdk 6.0.3 → 6.0.5-beta.0

package/src/leverage/operations.ts

@@ -1,4 +1,4 @@
-import { Address, IInstruction, Slot, Option, none, TransactionSigner, lamports } from '@solana/kit';
+import { LAMPORTS_PER_SOL, PublicKey, TransactionInstruction } from '@solana/web3.js';
 import Decimal from 'decimal.js';
 import {
   KaminoAction,
@@ -18,6 +18,7 @@ import {
   MultiplyObligation,
   ObligationType,
   ObligationTypeTag,
+  PublicKeySet,
   SOL_DECIMALS,
   ScopePriceRefreshConfig,
   U64_MAX,
@@ -25,10 +26,9 @@ import {
   getAssociatedTokenAddress,
   getComputeBudgetAndPriorityFeeIxs,
   getTransferWsolIxs,
+  getLookupTableAccount,
   removeBudgetIxs,
   uniqueAccountsWithProgramIds,
-  WRAPPED_SOL_MINT,
-  DEFAULT_PUBLIC_KEY,
 } from '../utils';
 import {
   adjustDepositLeverageCalcs,
@@ -38,6 +38,12 @@ import {
   depositLeverageKtokenCalcs,
   withdrawLeverageCalcs,
 } from './calcs';
+import {
+  NATIVE_MINT,
+  TOKEN_PROGRAM_ID,
+  createCloseAccountInstruction,
+  getAssociatedTokenAddressSync,
+} from '@solana/spl-token';
 import { Kamino, StrategyWithAddress } from '@kamino-finance/kliquidity-sdk';
 import { getExpectedTokenBalanceAfterBorrow, getKtokenToTokenSwapper, getTokenToKtokenSwapper } from './utils';
 import { FullBPS } from '@kamino-finance/kliquidity-sdk/dist/utils/CreationParameters';
@@ -64,10 +70,6 @@ import {
   LeverageIxsOutput,
   FlashLoanInfo,
 } from './types';
-import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
-import { findAssociatedTokenPda, getCloseAccountInstruction } from '@solana-program/token-2022';
-import { LAMPORTS_PER_SOL } from '../utils/consts';
-import { fetchAddressLookupTable } from '@solana-program/address-lookup-table';
 
 export async function getDepositWithLeverageSwapInputs<QuoteResponse>({
   owner,
@@ -97,13 +99,13 @@ export async function getDepositWithLeverageSwapInputs<QuoteResponse>({
   swapInputs: SwapInputs;
   initialInputs: DepositLeverageInitialInputs<QuoteResponse>;
 }> {
-  const collReserve = kaminoMarket.getExistingReserveByMint(collTokenMint);
-  const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
-  const solTokenReserve = kaminoMarket.getReserveByMint(WRAPPED_SOL_MINT);
+  const collReserve = kaminoMarket.getReserveByMint(collTokenMint)!;
+  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint)!;
+  const solTokenReserve = kaminoMarket.getReserveByMint(NATIVE_MINT);
   const flashLoanFee = collReserve.getFlashLoanFee() || new Decimal(0);
 
-  const selectedTokenIsCollToken = selectedTokenMint === collTokenMint;
-  const depositTokenIsSol = !solTokenReserve ? false : selectedTokenMint === solTokenReserve!.getLiquidityMint();
+  const selectedTokenIsCollToken = selectedTokenMint.equals(collTokenMint);
+  const depositTokenIsSol = !solTokenReserve ? false : selectedTokenMint.equals(solTokenReserve!.getLiquidityMint());
 
   const collIsKtoken = await isKtoken(collTokenMint);
   const strategy = collIsKtoken ? (await kamino!.getStrategyByKTokenMint(collTokenMint))! : undefined;
@@ -197,7 +199,7 @@ export async function getDepositWithLeverageSwapInputs<QuoteResponse>({
 
   if (collIsKtoken) {
     let futureBalanceInAta = new Decimal(0);
-    if (debtTokenMint === WRAPPED_SOL_MINT) {
+    if (debtTokenMint.equals(NATIVE_MINT)) {
       futureBalanceInAta = futureBalanceInAta.add(
         !collIsKtoken ? quotePriceCalcs.initDepositInSol : quotePriceCalcs.initDepositInSol
       );
@@ -206,9 +208,9 @@ export async function getDepositWithLeverageSwapInputs<QuoteResponse>({
       !collIsKtoken ? quotePriceCalcs.debtTokenToBorrow : quotePriceCalcs.flashBorrowInDebtTokenKtokenOnly
     );
     expectedDebtTokenAtaBalance = await getExpectedTokenBalanceAfterBorrow(
-      kaminoMarket.getRpc(),
+      kaminoMarket.getConnection(),
       debtTokenMint,
-      owner.address,
+      owner,
       toLamports(futureBalanceInAta.toDecimalPlaces(debtReserve.stats.decimals), debtReserve.stats.decimals),
       debtReserve.state.liquidity.mintDecimals.toNumber()
     );
@@ -249,7 +251,7 @@ async function getDepositWithLeverageCalcs(
   flashLoanFee: Decimal,
   kamino: Kamino | undefined,
   strategy: StrategyWithAddress | undefined,
-  debtTokenMint: Address,
+  debtTokenMint: PublicKey,
   priceAinB: PriceAinBProvider,
   debtReserve: KaminoReserve
 ): Promise<DepositLeverageCalcsResult> {
@@ -358,13 +360,13 @@ export async function getDepositWithLeverageIxs<QuoteResponse>({
   const swapsArray = await depositSwapper(swapInputs, initialInputs.klendAccounts, initialInputs.swapQuote);
 
   if (initialInputs.collIsKtoken) {
-    if (initialInputs.strategy && initialInputs.strategy.strategy.strategyLookupTable !== DEFAULT_PUBLIC_KEY) {
-      const strategyLut = await fetchAddressLookupTable(
-        kaminoMarket.getRpc(),
-        initialInputs.strategy.strategy.strategyLookupTable
+    if (initialInputs.strategy!.strategy.strategyLookupTable) {
+      const strategyLut = await getLookupTableAccount(
+        kaminoMarket.getConnection(),
+        initialInputs.strategy!.strategy.strategyLookupTable!
       );
       swapsArray.forEach((swap) => {
-        swap.lookupTables.push(strategyLut);
+        swap.lookupTables.push(strategyLut!);
       });
     } else {
       console.log('Strategy lookup table not found');
@@ -373,8 +375,8 @@ export async function getDepositWithLeverageIxs<QuoteResponse>({
 
   const collReserve = kaminoMarket.getReserveByMint(collTokenMint);
   const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
-  const solTokenReserve = kaminoMarket.getReserveByMint(WRAPPED_SOL_MINT);
-  const depositTokenIsSol = !solTokenReserve ? false : selectedTokenMint === solTokenReserve!.getLiquidityMint();
+  const solTokenReserve = kaminoMarket.getReserveByMint(NATIVE_MINT);
+  const depositTokenIsSol = !solTokenReserve ? false : selectedTokenMint.equals(solTokenReserve!.getLiquidityMint());
 
   return Promise.all(
     swapsArray.map(async (swap) => {
@@ -418,14 +420,14 @@ async function buildDepositWithLeverageIxs<QuoteResponse>(
   market: KaminoMarket,
   debtReserve: KaminoReserve,
   collReserve: KaminoReserve,
-  owner: TransactionSigner,
+  owner: PublicKey,
   obligation: KaminoObligation | ObligationType | undefined,
-  referrer: Option<Address>,
-  currentSlot: Slot,
+  referrer: PublicKey,
+  currentSlot: number,
   depositTokenIsSol: boolean,
   scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
   calcs: DepositLeverageCalcsResult,
-  budgetAndPriorityFeeIxs: IInstruction[] | undefined,
+  budgetAndPriorityFeeIxs: TransactionInstruction[] | undefined,
   swapQuoteIxs: SwapIxs<QuoteResponse>,
   strategy: StrategyWithAddress | undefined,
   collIsKtoken: boolean,
@@ -434,20 +436,21 @@ async function buildDepositWithLeverageIxs<QuoteResponse>(
 ): Promise<LeverageIxsOutput> {
   const collTokenMint = collReserve.getLiquidityMint();
   const debtTokenMint = debtReserve.getLiquidityMint();
-  const [[collTokenAta], [debtTokenAta]] = await Promise.all([
-    findAssociatedTokenPda({
-      owner: owner.address,
-      mint: collTokenMint,
-      tokenProgram: collReserve.getLiquidityTokenProgram(),
-    }),
-    findAssociatedTokenPda({
-      owner: owner.address,
-      mint: debtTokenMint,
-      tokenProgram: debtReserve.getLiquidityTokenProgram(),
-    }),
-  ]);
+  const collTokenAta = getAssociatedTokenAddressSync(
+    collTokenMint,
+    owner,
+    false,
+    collReserve.getLiquidityTokenProgram()
+  );
+  const debtTokenAta = getAssociatedTokenAddressSync(
+    debtTokenMint,
+    owner,
+    false,
+    debtReserve.getLiquidityTokenProgram()
+  );
 
   // 1. Create atas & budget ixs
+
   const { budgetIxs, createAtasIxs, scopeRefreshIx } = await getSetupIxs(
     owner,
     market,
@@ -462,13 +465,13 @@ async function buildDepositWithLeverageIxs<QuoteResponse>(
     budgetAndPriorityFeeIxs
   );
 
-  const fillWsolAtaIxs: IInstruction[] = [];
+  const fillWsolAtaIxs: TransactionInstruction[] = [];
   if (depositTokenIsSol) {
     fillWsolAtaIxs.push(
       ...getTransferWsolIxs(
         owner,
-        await getAssociatedTokenAddress(WRAPPED_SOL_MINT, owner.address),
-        lamports(BigInt(toLamports(calcs.initDepositInSol, SOL_DECIMALS).ceil().toString()))
+        getAssociatedTokenAddressSync(NATIVE_MINT, owner),
+        toLamports(calcs.initDepositInSol, SOL_DECIMALS).ceil()
       )
     );
   }
@@ -478,8 +481,8 @@ async function buildDepositWithLeverageIxs<QuoteResponse>(
   const { flashBorrowIx, flashRepayIx } = getFlashLoanInstructions({
     borrowIxIndex:
       budgetIxs.length + createAtasIxs.length + fillWsolAtaIxs.length + (scopeRefreshIx.length > 0 ? 1 : 0),
-    userTransferAuthority: owner,
-    lendingMarketAuthority: await market.getLendingMarketAuthority(),
+    walletPublicKey: owner,
+    lendingMarketAuthority: market.getLendingMarketAuthority(),
     lendingMarketAddress: market.getAddress(),
     reserve: !collIsKtoken ? collReserve : debtReserve,
     amountLamports: toLamports(
@@ -488,8 +491,8 @@ async function buildDepositWithLeverageIxs<QuoteResponse>(
     ),
     destinationAta: !collIsKtoken ? collTokenAta : debtTokenAta,
     // TODO(referrals): once we support referrals, we will have to replace the placeholder args below:
-    referrerAccount: none(),
-    referrerTokenState: none(),
+    referrerAccount: market.programId,
+    referrerTokenState: market.programId,
     programId: market.programId,
   });
 
@@ -571,11 +574,11 @@ export async function getWithdrawWithLeverageSwapInputs<QuoteResponse>({
   const collReserve = kaminoMarket.getReserveByMint(collTokenMint);
   const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
   const flashLoanFee = debtReserve!.getFlashLoanFee() || new Decimal(0);
-  const selectedTokenIsCollToken = selectedTokenMint === collTokenMint;
+  const selectedTokenIsCollToken = selectedTokenMint.equals(collTokenMint);
   const collIsKtoken = await isKtoken(collTokenMint);
   const strategy = collIsKtoken ? (await kamino!.getStrategyByKTokenMint(collTokenMint))! : undefined;
 
-  const inputTokenIsSol = selectedTokenMint === WRAPPED_SOL_MINT;
+  const inputTokenIsSol = selectedTokenMint.equals(NATIVE_MINT);
 
   const calcs = withdrawLeverageCalcs(
     kaminoMarket,
@@ -701,7 +704,7 @@ export async function getWithdrawWithLeverageIxs<QuoteResponse>({
   const collReserve = kaminoMarket.getReserveByMint(collTokenMint);
   const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
 
-  const inputTokenIsSol = selectedTokenMint === WRAPPED_SOL_MINT;
+  const inputTokenIsSol = selectedTokenMint.equals(NATIVE_MINT);
   const { swapInputs, initialInputs } = await getWithdrawWithLeverageSwapInputs({
     owner,
     kaminoMarket,
@@ -740,13 +743,13 @@ export async function getWithdrawWithLeverageIxs<QuoteResponse>({
   const swapsArray = await withdrawSwapper(swapInputs, initialInputs.klendAccounts, initialInputs.swapQuote);
 
   if (initialInputs.collIsKtoken) {
-    if (initialInputs.strategy?.strategy.strategyLookupTable) {
-      const strategyLut = await fetchAddressLookupTable(
-        kaminoMarket.getRpc(),
-        initialInputs.strategy.strategy.strategyLookupTable
+    if (initialInputs.strategy!.strategy.strategyLookupTable) {
+      const strategyLut = await getLookupTableAccount(
+        kaminoMarket.getConnection(),
+        initialInputs.strategy!.strategy.strategyLookupTable!
       );
       swapsArray.forEach((swap) => {
-        swap.lookupTables.push(strategyLut);
+        swap.lookupTables.push(strategyLut!);
       });
     } else {
       console.log('Strategy lookup table not found');
@@ -796,15 +799,15 @@ export async function buildWithdrawWithLeverageIxs<QuoteResponse>(
   market: KaminoMarket,
   debtReserve: KaminoReserve,
   collReserve: KaminoReserve,
-  owner: TransactionSigner,
+  owner: PublicKey,
   obligation: KaminoObligation,
-  referrer: Option<Address>,
-  currentSlot: Slot,
+  referrer: PublicKey,
+  currentSlot: number,
   isClosingPosition: boolean,
   depositTokenIsSol: boolean,
   scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
   calcs: WithdrawLeverageCalcsResult,
-  budgetAndPriorityFeeIxs: IInstruction[] | undefined,
+  budgetAndPriorityFeeIxs: TransactionInstruction[] | undefined,
   swapQuoteIxs: SwapIxs<QuoteResponse>,
   strategy: StrategyWithAddress | undefined,
   collIsKtoken: boolean,
@@ -812,9 +815,10 @@ export async function buildWithdrawWithLeverageIxs<QuoteResponse>(
 ): Promise<LeverageIxsOutput> {
   const collTokenMint = collReserve.getLiquidityMint();
   const debtTokenMint = debtReserve.getLiquidityMint();
-  const debtTokenAta = await getAssociatedTokenAddress(
+  const debtTokenAta = getAssociatedTokenAddressSync(
     debtTokenMint,
-    owner.address,
+    owner,
+    false,
     debtReserve.getLiquidityTokenProgram()
   );
   // 1. Create atas & budget txns & user metadata
@@ -833,33 +837,23 @@ export async function buildWithdrawWithLeverageIxs<QuoteResponse>(
     budgetAndPriorityFeeIxs
   );
 
-  const closeWsolAtaIxs: IInstruction[] = [];
-  if (depositTokenIsSol || debtTokenMint === WRAPPED_SOL_MINT) {
-    const wsolAta = await getAssociatedTokenAddress(WRAPPED_SOL_MINT, owner.address);
-    closeWsolAtaIxs.push(
-      getCloseAccountInstruction(
-        {
-          owner,
-          destination: owner.address,
-          account: wsolAta,
-        },
-        { programAddress: TOKEN_PROGRAM_ADDRESS }
-      )
-    );
+  const closeWsolAtaIxs: TransactionInstruction[] = [];
+  if (depositTokenIsSol || debtTokenMint.equals(NATIVE_MINT)) {
+    const wsolAta = getAssociatedTokenAddress(NATIVE_MINT, owner, false);
+    closeWsolAtaIxs.push(createCloseAccountInstruction(wsolAta, owner, owner, [], TOKEN_PROGRAM_ID));
   }
 
   // TODO: Mihai/Marius check if we can improve this logic and not convert any SOL
   // This is here so that we have enough wsol to repay in case the kAB swapped to sol after estimates is not enough
-  const fillWsolAtaIxs: IInstruction[] = [];
-  if (debtTokenMint === WRAPPED_SOL_MINT) {
-    const halfSolBalance =
-      Number.parseInt((await market.getRpc().getBalance(owner.address).send()).value.toString()) / LAMPORTS_PER_SOL / 2;
+  const fillWsolAtaIxs: TransactionInstruction[] = [];
+  if (debtTokenMint.equals(NATIVE_MINT)) {
+    const halfSolBalance = (await market.getConnection().getBalance(owner)) / LAMPORTS_PER_SOL / 2;
     const balanceToWrap = halfSolBalance < 0.1 ? halfSolBalance : 0.1;
     fillWsolAtaIxs.push(
       ...getTransferWsolIxs(
         owner,
-        await getAssociatedTokenAddress(WRAPPED_SOL_MINT, owner.address),
-        lamports(BigInt(toLamports(balanceToWrap, SOL_DECIMALS).ceil().toString()))
+        getAssociatedTokenAddressSync(NATIVE_MINT, owner),
+        toLamports(balanceToWrap, SOL_DECIMALS).ceil()
       )
     );
   }
@@ -870,15 +864,15 @@ export async function buildWithdrawWithLeverageIxs<QuoteResponse>(
   const { flashBorrowIx, flashRepayIx } = getFlashLoanInstructions({
     borrowIxIndex:
       budgetIxs.length + createAtasIxs.length + fillWsolAtaIxs.length + (scopeRefreshIx.length > 0 ? 1 : 0),
-    userTransferAuthority: owner,
-    lendingMarketAuthority: await market.getLendingMarketAuthority(),
+    walletPublicKey: owner,
+    lendingMarketAuthority: market.getLendingMarketAuthority(),
     lendingMarketAddress: market.getAddress(),
     reserve: debtReserve!,
     amountLamports: toLamports(calcs.repayAmount, debtReserve!.stats.decimals),
     destinationAta: debtTokenAta,
     // TODO(referrals): once we support referrals, we will have to replace the placeholder args below:
-    referrerAccount: none(),
-    referrerTokenState: none(),
+    referrerAccount: market.programId,
+    referrerTokenState: market.programId,
     programId: market.programId,
   });
 
@@ -983,7 +977,7 @@ export async function getAdjustLeverageSwapInputs<QuoteResponse>({
   if (isDeposit) {
     const calcs = await adjustDepositLeverageCalcs(
       kaminoMarket,
-      owner.address,
+      owner,
       debtReserve!,
       adjustDepositPosition,
       adjustBorrowPosition,
@@ -1048,7 +1042,7 @@ export async function getAdjustLeverageSwapInputs<QuoteResponse>({
 
     const calcsQuotePrice = await adjustDepositLeverageCalcs(
       kaminoMarket,
-      owner.address,
+      owner,
       debtReserve,
       adjustDepositPositionQuotePrice,
       adjustBorrowPositionQuotePrice,
@@ -1066,9 +1060,9 @@ export async function getAdjustLeverageSwapInputs<QuoteResponse>({
     let expectedDebtTokenAtaBalance = new Decimal(0);
     if (collIsKtoken) {
       expectedDebtTokenAtaBalance = await getExpectedTokenBalanceAfterBorrow(
-        kaminoMarket.getRpc(),
+        kaminoMarket.getConnection(),
         debtTokenMint,
-        owner.address,
+        owner,
         toLamports(
           !collIsKtoken ? calcsQuotePrice.borrowAmount : calcsQuotePrice.amountToFlashBorrowDebt,
           debtReserve.stats.decimals
@@ -1352,27 +1346,35 @@ export async function getAdjustLeverageIxs<QuoteResponse>({
  * Deposit and borrow tokens if leverage increased
  */
 async function buildIncreaseLeverageIxs<QuoteResponse>(
-  owner: TransactionSigner,
+  owner: PublicKey,
   kaminoMarket: KaminoMarket,
-  collTokenMint: Address,
-  debtTokenMint: Address,
+  collTokenMint: PublicKey,
+  debtTokenMint: PublicKey,
   obligation: KaminoObligation,
-  referrer: Option<Address>,
-  currentSlot: Slot,
+  referrer: PublicKey,
+  currentSlot: number,
   calcs: AdjustLeverageCalcsResult,
   strategy: StrategyWithAddress | undefined,
   scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
   collIsKtoken: boolean,
   swapQuoteIxs: SwapIxs<QuoteResponse>,
-  budgetAndPriorityFeeIxs: IInstruction[] | undefined,
+  budgetAndPriorityFeeIxs: TransactionInstruction[] | undefined,
   useV2Ixs: boolean
 ): Promise<LeverageIxsOutput> {
   const collReserve = kaminoMarket.getExistingReserveByMint(collTokenMint);
   const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
-  const [debtTokenAta, collTokenAta] = await Promise.all([
-    getAssociatedTokenAddress(debtTokenMint, owner.address, debtReserve.getLiquidityTokenProgram()),
-    getAssociatedTokenAddress(collTokenMint, owner.address, collReserve.getLiquidityTokenProgram()),
-  ]);
+  const debtTokenAta = getAssociatedTokenAddressSync(
+    debtTokenMint,
+    owner,
+    false,
+    debtReserve.getLiquidityTokenProgram()
+  );
+  const collTokenAta = getAssociatedTokenAddressSync(
+    collTokenMint,
+    owner,
+    false,
+    collReserve.getLiquidityTokenProgram()
+  );
 
   // 1. Create atas & budget txns
   const { budgetIxs, createAtasIxs, scopeRefreshIx } = await getSetupIxs(
@@ -1392,8 +1394,8 @@ async function buildIncreaseLeverageIxs<QuoteResponse>(
   // 2. Create borrow flash loan instruction
   const { flashBorrowIx, flashRepayIx } = getFlashLoanInstructions({
     borrowIxIndex: budgetIxs.length + createAtasIxs.length + (scopeRefreshIx.length > 0 ? 1 : 0), // TODO: how about user metadata ixs
-    userTransferAuthority: owner,
-    lendingMarketAuthority: await kaminoMarket.getLendingMarketAuthority(),
+    walletPublicKey: owner,
+    lendingMarketAuthority: kaminoMarket.getLendingMarketAuthority(),
     lendingMarketAddress: kaminoMarket.getAddress(),
     reserve: !collIsKtoken ? collReserve! : debtReserve!,
     amountLamports: toLamports(
@@ -1402,8 +1404,8 @@ async function buildIncreaseLeverageIxs<QuoteResponse>(
     ),
     destinationAta: !collIsKtoken ? collTokenAta : debtTokenAta,
     // TODO(referrals): once we support referrals, we will have to replace the placeholder args below:
-    referrerAccount: none(),
-    referrerTokenState: none(),
+    referrerAccount: kaminoMarket.programId,
+    referrerTokenState: kaminoMarket.programId,
     programId: kaminoMarket.programId,
   });
 
@@ -1470,28 +1472,29 @@ async function buildIncreaseLeverageIxs<QuoteResponse>(
  * Withdraw and repay tokens if leverage decreased
  */
 async function buildDecreaseLeverageIxs<QuoteResponse>(
-  owner: TransactionSigner,
+  owner: PublicKey,
   kaminoMarket: KaminoMarket,
-  collTokenMint: Address,
-  debtTokenMint: Address,
+  collTokenMint: PublicKey,
+  debtTokenMint: PublicKey,
   obligation: KaminoObligation,
-  referrer: Option<Address>,
-  currentSlot: Slot,
+  referrer: PublicKey,
+  currentSlot: number,
   calcs: AdjustLeverageCalcsResult,
   strategy: StrategyWithAddress | undefined,
   scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
   collIsKtoken: boolean,
   swapQuoteIxs: SwapIxs<QuoteResponse>,
-  budgetAndPriorityFeeIxs: IInstruction[] | undefined,
+  budgetAndPriorityFeeIxs: TransactionInstruction[] | undefined,
   useV2Ixs: boolean
 ): Promise<LeverageIxsOutput> {
   const collReserve = kaminoMarket.getExistingReserveByMint(collTokenMint);
   const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
-  const [debtTokenAta] = await findAssociatedTokenPda({
-    owner: owner.address,
-    mint: debtTokenMint,
-    tokenProgram: debtReserve.getLiquidityTokenProgram(),
-  });
+  const debtTokenAta = getAssociatedTokenAddressSync(
+    debtTokenMint,
+    owner,
+    false,
+    debtReserve.getLiquidityTokenProgram()
+  );
 
   // 1. Create atas & budget txns
   const { budgetIxs, createAtasIxs, scopeRefreshIx } = await getSetupIxs(
@@ -1510,33 +1513,17 @@ async function buildDecreaseLeverageIxs<QuoteResponse>(
 
   // TODO: Mihai/Marius check if we can improve this logic and not convert any SOL
   // This is here so that we have enough wsol to repay in case the kAB swapped to sol after estimates is not enough
-  const closeWsolAtaIxs: IInstruction[] = [];
-  const fillWsolAtaIxs: IInstruction[] = [];
-  if (debtTokenMint === WRAPPED_SOL_MINT) {
-    const wsolAta = await getAssociatedTokenAddress(WRAPPED_SOL_MINT, owner.address);
+  const closeWsolAtaIxs: TransactionInstruction[] = [];
+  const fillWsolAtaIxs: TransactionInstruction[] = [];
+  if (debtTokenMint.equals(NATIVE_MINT)) {
+    const wsolAta = getAssociatedTokenAddress(NATIVE_MINT, owner, false);
 
-    closeWsolAtaIxs.push(
-      getCloseAccountInstruction(
-        {
-          owner,
-          account: wsolAta,
-          destination: owner.address,
-        },
-        { programAddress: TOKEN_PROGRAM_ADDRESS }
-      )
-    );
+    closeWsolAtaIxs.push(createCloseAccountInstruction(wsolAta, owner, owner, [], TOKEN_PROGRAM_ID));
 
-    const halfSolBalance =
-      Number.parseInt((await kaminoMarket.getRpc().getBalance(owner.address).send()).value.toString()) /
-      LAMPORTS_PER_SOL /
-      2;
+    const halfSolBalance = (await kaminoMarket.getConnection().getBalance(owner)) / LAMPORTS_PER_SOL / 2;
     const balanceToWrap = halfSolBalance < 0.1 ? halfSolBalance : 0.1;
     fillWsolAtaIxs.push(
-      ...getTransferWsolIxs(
-        owner,
-        wsolAta,
-        lamports(BigInt(toLamports(balanceToWrap, debtReserve!.stats.decimals).ceil().toString()))
-      )
+      ...getTransferWsolIxs(owner, wsolAta, toLamports(balanceToWrap, debtReserve!.stats.decimals).ceil())
     );
   }
 
@@ -1544,15 +1531,15 @@ async function buildDecreaseLeverageIxs<QuoteResponse>(
   const { flashBorrowIx, flashRepayIx } = getFlashLoanInstructions({
     borrowIxIndex:
       budgetIxs.length + createAtasIxs.length + fillWsolAtaIxs.length + (scopeRefreshIx.length > 0 ? 1 : 0),
-    userTransferAuthority: owner,
-    lendingMarketAuthority: await kaminoMarket.getLendingMarketAuthority(),
+    walletPublicKey: owner,
+    lendingMarketAuthority: kaminoMarket.getLendingMarketAuthority(),
     lendingMarketAddress: kaminoMarket.getAddress(),
     reserve: debtReserve!,
     amountLamports: toLamports(Decimal.abs(calcs.adjustBorrowPosition), debtReserve!.stats.decimals),
     destinationAta: debtTokenAta,
     // TODO(referrals): once we support referrals, we will have to replace the placeholder args below:
-    referrerAccount: none(),
-    referrerTokenState: none(),
+    referrerAccount: kaminoMarket.programId,
+    referrerTokenState: kaminoMarket.programId,
     programId: kaminoMarket.programId,
   });
 
@@ -1618,17 +1605,17 @@ async function buildDecreaseLeverageIxs<QuoteResponse>(
 }
 
 export const getSetupIxs = async (
-  owner: TransactionSigner,
+  owner: PublicKey,
   kaminoMarket: KaminoMarket,
   obligation: KaminoObligation | ObligationType | undefined,
-  collTokenMint: Address,
+  collTokenMint: PublicKey,
   collReserve: KaminoReserve,
   collIsKtoken: boolean,
-  debtTokenMint: Address,
+  debtTokenMint: PublicKey,
   debtReserve: KaminoReserve,
   strategy: StrategyWithAddress | undefined,
   scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
-  budgetAndPriorityFeeIxs: IInstruction[] | undefined
+  budgetAndPriorityFeeIxs: TransactionInstruction[] | undefined
 ) => {
   const budgetIxs = budgetAndPriorityFeeIxs || getComputeBudgetAndPriorityFeeIxs(3000000);
 
@@ -1641,7 +1628,7 @@ export const getSetupIxs = async (
     strategy
   );
 
-  const createAtasIxs = (await createAtasIdempotent(owner, mintsWithTokenPrograms)).map((x) => x.createAtaIx);
+  const createAtasIxs = createAtasIdempotent(owner, mintsWithTokenPrograms).map((x) => x.createAtaIx);
 
   const scopeRefreshIx = await getScopeRefreshIx(
     kaminoMarket,
@@ -1664,21 +1651,19 @@ export const getScopeRefreshIx = async (
   debtReserve: KaminoReserve,
   obligation: KaminoObligation | ObligationType | undefined,
   scopeRefreshConfig: ScopePriceRefreshConfig | undefined
-): Promise<IInstruction[]> => {
+): Promise<TransactionInstruction[]> => {
   const allReserves =
     obligation && isKaminoObligation(obligation)
-      ? [
-          ...new Set<Address>([
-            ...obligation.getDeposits().map((x) => x.reserveAddress),
-            ...obligation.getBorrows().map((x) => x.reserveAddress),
-            collReserve.address,
-            debtReserve.address,
-          ]),
-        ]
-      : [...new Set<Address>([collReserve.address, debtReserve.address])];
+      ? new PublicKeySet<PublicKey>([
+          ...obligation.getDeposits().map((x) => x.reserveAddress),
+          ...obligation.getBorrows().map((x) => x.reserveAddress),
+          collReserve.address,
+          debtReserve.address,
+        ]).toArray()
+      : new PublicKeySet<PublicKey>([collReserve.address, debtReserve.address]).toArray();
   const tokenIds = getTokenIdsForScopeRefresh(market, allReserves);
 
-  const scopeRefreshIxs: IInstruction[] = [];
+  const scopeRefreshIxs: TransactionInstruction[] = [];
   if (tokenIds.length > 0 && scopeRefreshConfig) {
     scopeRefreshIxs.push(
       await scopeRefreshConfig.scope.refreshPriceListIx(
@@ -1695,8 +1680,8 @@ export const getScopeRefreshIx = async (
 
 const checkObligationType = (
   obligationTypeTag: ObligationTypeTag,
-  collTokenMint: Address,
-  debtTokenMint: Address,
+  collTokenMint: PublicKey,
+  debtTokenMint: PublicKey,
   kaminoMarket: KaminoMarket
 ) => {
   let obligationType: ObligationType;
@@ -1714,14 +1699,14 @@ const checkObligationType = (
 };
 
 type MintWithTokenProgram = {
-  mint: Address;
-  tokenProgram: Address;
+  mint: PublicKey;
+  tokenProgram: PublicKey;
 };
 
 const getTokenMintsWithTokenPrograms = (
-  collTokenMint: Address,
+  collTokenMint: PublicKey,
   collReserve: KaminoReserve,
-  debtTokenMint: Address,
+  debtTokenMint: PublicKey,
   debtReserve: KaminoReserve,
   collIsKtoken: boolean,
   strategy: StrategyWithAddress | undefined
@@ -1737,25 +1722,23 @@ const getTokenMintsWithTokenPrograms = (
     },
     {
       mint: collReserve.getCTokenMint(),
-      tokenProgram: TOKEN_PROGRAM_ADDRESS,
+      tokenProgram: TOKEN_PROGRAM_ID,
     },
   ];
 
   if (collIsKtoken) {
-    let kTokenAta: Address;
-    let kTokenTokenProgram: Address;
-    if (strategy!.strategy.tokenAMint === debtTokenMint) {
+    let kTokenAta: PublicKey;
+    let kTokenTokenProgram: PublicKey;
+    if (strategy!.strategy.tokenAMint.equals(debtTokenMint)) {
       kTokenAta = strategy!.strategy.tokenBMint;
-      kTokenTokenProgram =
-        strategy!.strategy.tokenBTokenProgram === DEFAULT_PUBLIC_KEY
-          ? TOKEN_PROGRAM_ADDRESS
-          : strategy!.strategy.tokenBTokenProgram;
+      kTokenTokenProgram = strategy!.strategy.tokenBTokenProgram.equals(PublicKey.default)
+        ? TOKEN_PROGRAM_ID
+        : strategy!.strategy.tokenBTokenProgram;
     } else {
       kTokenAta = strategy!.strategy.tokenAMint;
-      kTokenTokenProgram =
-        strategy!.strategy.tokenATokenProgram === DEFAULT_PUBLIC_KEY
-          ? TOKEN_PROGRAM_ADDRESS
-          : strategy!.strategy.tokenATokenProgram;
+      kTokenTokenProgram = strategy!.strategy.tokenATokenProgram.equals(PublicKey.default)
+        ? TOKEN_PROGRAM_ID
+        : strategy!.strategy.tokenATokenProgram;
     }
 
     mintsWithTokenPrograms.push({