@kamino-finance/klend-sdk 5.14.2 → 5.14.4

package/src/classes/utils.ts

@@ -287,6 +287,18 @@ export function orThrow(message: string): never {
   throw new Error(message);
 }
 
+export function blobEquals(left: Uint8Array, right: Uint8Array): boolean {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let i = 0; i < left.length; ++i) {
+    if (left[i] !== right[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
 /**
  * Returns an integer {@link Decimal} nearest to the given one.
  *

package/src/classes/vault.ts

@@ -11,7 +11,13 @@ import {
   SYSVAR_RENT_PUBKEY,
   TransactionInstruction,
 } from '@solana/web3.js';
-import { getAssociatedTokenAddressSync, NATIVE_MINT, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
+import {
+  createCloseAccountInstruction,
+  getAssociatedTokenAddressSync,
+  NATIVE_MINT,
+  TOKEN_PROGRAM_ID,
+  unpackAccount,
+} from '@solana/spl-token';
 import {
   getAssociatedTokenAddress,
   getTransferWsolIxs,
@@ -1064,6 +1070,7 @@ export class KaminoVaultClient {
     const withdrawIxs: WithdrawIxs = {
       unstakeFromFarmIfNeededIxs: [],
       withdrawIxs: [],
+      postWithdrawIxs: [],
     };
 
     const shareLamportsToWithdraw = collToLamportsDecimal(shareAmount, vaultState.sharesMintDecimals.toNumber());
@@ -1099,6 +1106,13 @@ export class KaminoVaultClient {
       withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
     }
 
+    // if the vault is for SOL return the ix to unwrap the SOL
+    if (vaultState.tokenMint.equals(NATIVE_MINT)) {
+      const userWsolAta = getAssociatedTokenAddress(NATIVE_MINT, user);
+      const unwrapIx = createCloseAccountInstruction(userWsolAta, user, user, [], TOKEN_PROGRAM_ID);
+      withdrawIxs.postWithdrawIxs.push(unwrapIx);
+    }
+
     return withdrawIxs;
   }
 

package/src/classes/vault_types.ts

@@ -48,6 +48,7 @@ export type DepositIxs = {
 export type WithdrawIxs = {
   unstakeFromFarmIfNeededIxs: TransactionInstruction[];
   withdrawIxs: TransactionInstruction[];
+  postWithdrawIxs: TransactionInstruction[]; // wSOL ATA close ix 
 };
 
 /** The shares an user has in a vault (staked and unstaked), in tokens */

package/src/client_kamino_manager.ts

@@ -895,7 +895,7 @@ async function main() {
       const withdrawSig = await processTxn(
         env.client,
         env.payer,
-        [...withdrawIxs.unstakeFromFarmIfNeededIxs, ...withdrawIxs.withdrawIxs],
+        [...withdrawIxs.unstakeFromFarmIfNeededIxs, ...withdrawIxs.withdrawIxs, ...withdrawIxs.postWithdrawIxs],
         mode,
         2500,
         [],
@@ -1156,6 +1156,10 @@ async function main() {
       printHoldings(holdings);
       console.log(`Tokens per share for vault ${vaultAddress.toBase58()}: ${tokensPerShare}`);
       console.log('vaultOverview', vaultOverview);
+
+      for (const [reserveAddress, reserveOverview] of vaultOverview.reservesOverview) {
+        console.log(`reserve ${reserveAddress.toBase58()} supplyAPY ${reserveOverview.supplyAPY}`);
+      }
     });
 
   commands.command('get-oracle-mappings').action(async () => {

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -28,6 +28,7 @@ export type RepayWithCollIxsResponse<QuoteResponse> = {
   flashLoanInfo: FlashLoanInfo;
   swapInputs: SwapInputs;
   initialInputs: RepayWithCollInitialInputs<QuoteResponse>;
+  quote?: QuoteResponse;
 };
 
 export type RepayWithCollInitialInputs<QuoteResponse> = {
@@ -129,6 +130,7 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
       preActionIxs: [],
       swapIxs: [],
       lookupTables: [],
+      quote: {} as SwapQuote<QuoteResponse>,
     },
     isClosingPosition,
     repayAmountLamports,
@@ -193,7 +195,7 @@ export async function getRepayWithCollIxs<QuoteResponse>({
   scopeRefreshConfig,
   useV2Ixs,
   logger = console.log,
-}: RepayWithCollIxsProps<QuoteResponse>): Promise<RepayWithCollIxsResponse<QuoteResponse>> {
+}: RepayWithCollIxsProps<QuoteResponse>): Promise<Array<RepayWithCollIxsResponse<QuoteResponse>>> {
   const { swapInputs, initialInputs } = await getRepayWithCollSwapInputs({
     collTokenMint,
     currentSlot,
@@ -234,33 +236,39 @@ export async function getRepayWithCollIxs<QuoteResponse>({
       .div(actualSwapInLamports.div(collReserve.getMintFactor()))} ${debtReserve.symbol}/${collReserve.symbol}`
   );
 
-  const swapResponse = await swapper(swapInputs, initialInputs.klendAccounts, swapQuote);
-  const ixs: LeverageIxsOutput = await buildRepayWithCollateralIxs(
-    kaminoMarket,
-    debtReserve,
-    collReserve,
-    obligation,
-    referrer,
-    currentSlot,
-    budgetAndPriorityFeeIxs,
-    scopeRefreshConfig,
-    swapResponse,
-    isClosingPosition,
-    debtRepayAmountLamports,
-    swapInputs.inputAmountLamports,
-    useV2Ixs
+  const swapResponses = await swapper(swapInputs, initialInputs.klendAccounts, swapQuote);
+
+  return Promise.all(
+    swapResponses.map(async (swapResponse) => {
+      const ixs: LeverageIxsOutput = await buildRepayWithCollateralIxs(
+        kaminoMarket,
+        debtReserve,
+        collReserve,
+        obligation,
+        referrer,
+        currentSlot,
+        budgetAndPriorityFeeIxs,
+        scopeRefreshConfig,
+        swapResponse,
+        isClosingPosition,
+        debtRepayAmountLamports,
+        swapInputs.inputAmountLamports,
+        useV2Ixs
+      );
+
+      return {
+        ixs: ixs.instructions,
+        lookupTables: swapResponse.lookupTables,
+        swapInputs,
+        flashLoanInfo: ixs.flashLoanInfo,
+        initialInputs,
+        quote: swapResponse.quote.quoteResponse,
+      };
+    })
   );
-
-  return {
-    ixs: ixs.instructions,
-    lookupTables: swapResponse.lookupTables,
-    swapInputs,
-    flashLoanInfo: ixs.flashLoanInfo,
-    initialInputs,
-  };
 }
 
-async function buildRepayWithCollateralIxs(
+async function buildRepayWithCollateralIxs<QuoteResponse>(
   market: KaminoMarket,
   debtReserve: KaminoReserve,
   collReserve: KaminoReserve,
@@ -269,7 +277,7 @@ async function buildRepayWithCollateralIxs(
   currentSlot: number,
   budgetAndPriorityFeeIxs: TransactionInstruction[] | undefined,
   scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
-  swapQuoteIxs: SwapIxs,
+  swapQuoteIxs: SwapIxs<QuoteResponse>,
   isClosingPosition: boolean,
   debtRepayAmountLamports: Decimal,
   collWithdrawLamports: Decimal,

package/src/lending_operations/swap_collateral_operations.ts

@@ -145,7 +145,7 @@ export interface SwapCollIxsOutputs<QuoteResponse> {
  */
 export async function getSwapCollIxs<QuoteResponse>(
   inputs: SwapCollIxsInputs<QuoteResponse>
-): Promise<SwapCollIxsOutputs<QuoteResponse>> {
+): Promise<Array<SwapCollIxsOutputs<QuoteResponse>>> {
   const [args, context] = extractArgsAndContext(inputs);
 
   // Conceptually, we need to construct the following ixs:
@@ -165,33 +165,37 @@ export async function getSwapCollIxs<QuoteResponse>(
   const klendAccounts = uniqueAccountsWithProgramIds(listIxs(fakeKlendIxs));
 
   // Construct the external swap ixs (and learn the actual swap-out amount):
-  const externalSwapIxs = await getExternalSwapIxs(args, klendAccounts, context);
+  const externalSwapIxsArray = await getExternalSwapIxs(args, klendAccounts, context);
 
-  // We now have the full information needed to simulate the end-state, so let's check that the operation is legal:
-  context.logger(
-    `Expected to swap ${args.sourceCollSwapAmount} ${context.sourceCollReserve.symbol} collateral into ${externalSwapIxs.swapOutAmount} ${context.targetCollReserve.symbol} collateral`
+  return Promise.all(
+    externalSwapIxsArray.map(async (externalSwapIxs) => {
+      // We now have the full information needed to simulate the end-state, so let's check that the operation is legal:
+      context.logger(
+        `Expected to swap ${args.sourceCollSwapAmount} ${context.sourceCollReserve.symbol} collateral into ${externalSwapIxs.swapOutAmount} ${context.targetCollReserve.symbol} collateral`
+      );
+      checkResultingObligationValid(args, externalSwapIxs.swapOutAmount, context);
+
+      // Construct the Klend's own ixs with an actual swap-out amount:
+      const klendIxs = await getKlendIxs(args, externalSwapIxs.swapOutAmount, context);
+
+      return {
+        ixs: listIxs(klendIxs, externalSwapIxs.ixs),
+        lookupTables: externalSwapIxs.luts,
+        useV2Ixs: context.useV2Ixs,
+        simulationDetails: {
+          flashLoan: {
+            targetCollFlashBorrowedAmount: klendIxs.simulationDetails.targetCollFlashBorrowedAmount,
+            targetCollFlashRepaidAmount: externalSwapIxs.swapOutAmount,
+          },
+          externalSwap: {
+            sourceCollSwapInAmount: args.sourceCollSwapAmount, // repeated `/inputs.sourceCollSwapAmount`, only for clarity
+            targetCollSwapOutAmount: externalSwapIxs.swapOutAmount, // repeated `../flashLoan.targetCollFlashRepaidAmount`, only for clarity
+            quoteResponse: externalSwapIxs.simulationDetails.quoteResponse,
+          },
+        },
+      };
+    })
   );
-  checkResultingObligationValid(args, externalSwapIxs.swapOutAmount, context);
-
-  // Construct the Klend's own ixs with an actual swap-out amount:
-  const klendIxs = await getKlendIxs(args, externalSwapIxs.swapOutAmount, context);
-
-  return {
-    ixs: listIxs(klendIxs, externalSwapIxs.ixs),
-    lookupTables: externalSwapIxs.luts,
-    useV2Ixs: context.useV2Ixs,
-    simulationDetails: {
-      flashLoan: {
-        targetCollFlashBorrowedAmount: klendIxs.simulationDetails.targetCollFlashBorrowedAmount,
-        targetCollFlashRepaidAmount: externalSwapIxs.swapOutAmount,
-      },
-      externalSwap: {
-        sourceCollSwapInAmount: args.sourceCollSwapAmount, // repeated `/inputs.sourceCollSwapAmount`, only for clarity
-        targetCollSwapOutAmount: externalSwapIxs.swapOutAmount, // repeated `../flashLoan.targetCollFlashRepaidAmount`, only for clarity
-        quoteResponse: externalSwapIxs.simulationDetails.quoteResponse,
-      },
-    },
-  };
 }
 
 type SwapCollArgs = {
@@ -508,7 +512,7 @@ async function getExternalSwapIxs<QuoteResponse>(
   args: SwapCollArgs,
   klendAccounts: PublicKey[],
   context: SwapCollContext<QuoteResponse>
-): Promise<ExternalSwapIxs<QuoteResponse>> {
+): Promise<Array<ExternalSwapIxs<QuoteResponse>>> {
   const externalSwapInputs = {
     inputAmountLamports: args.sourceCollSwapAmount.mul(context.sourceCollReserve.getMintFactor()),
     inputMint: context.sourceCollReserve.getLiquidityMint(),
@@ -516,17 +520,20 @@ async function getExternalSwapIxs<QuoteResponse>(
     amountDebtAtaBalance: undefined, // only used for kTokens
   };
   const externalSwapQuote = await context.quoter(externalSwapInputs, klendAccounts);
-  const swapOutAmount = externalSwapQuote.priceAInB.mul(args.sourceCollSwapAmount);
   const externalSwapIxsAndLuts = await context.swapper(externalSwapInputs, klendAccounts, externalSwapQuote);
+
   // Note: we can ignore the returned `preActionIxs` field - we do not request any of them from the swapper.
-  return {
-    swapOutAmount,
-    ixs: externalSwapIxsAndLuts.swapIxs,
-    luts: externalSwapIxsAndLuts.lookupTables,
-    simulationDetails: {
-      quoteResponse: externalSwapQuote.quoteResponse,
-    },
-  };
+  return externalSwapIxsAndLuts.map((externalSwapIxsAndLuts) => {
+    const swapOutAmount = externalSwapIxsAndLuts.quote.priceAInB.mul(args.sourceCollSwapAmount);
+    return {
+      swapOutAmount,
+      ixs: externalSwapIxsAndLuts.swapIxs,
+      luts: externalSwapIxsAndLuts.lookupTables,
+      simulationDetails: {
+        quoteResponse: externalSwapIxsAndLuts.quote.quoteResponse,
+      },
+    };
+  });
 }
 
 function checkResultingObligationValid(