@kamino-finance/klend-sdk 7.1.1 → 7.1.3

package/src/leverage/types.ts

@@ -1,7 +1,6 @@
 import { Account, Address, Instruction, Option, Slot, TransactionSigner } from '@solana/kit';
 import Decimal from 'decimal.js';
 import { KaminoMarket, KaminoObligation } from '../classes';
-import { Kamino, StrategyWithAddress } from '@kamino-finance/kliquidity-sdk';
 import { ObligationType, ObligationTypeTag, ScopePriceRefreshConfig } from '../utils';
 import { AddressLookupTable } from '@solana-program/address-lookup-table';
 
@@ -30,8 +29,6 @@ export type SwapIxs<QuoteResponse> = {
 
 export type PriceAinBProvider = (mintA: Address, mintB: Address) => Promise<Decimal>;
 
-export type IsKtokenProvider = (token: Address) => Promise<boolean>;
-
 export type FlashLoanInfo = {
   flashBorrowReserve: Address;
   flashLoanFee: Decimal;
@@ -47,7 +44,6 @@ export type SwapInputs = {
   minOutAmountLamports?: Decimal;
   inputMint: Address;
   outputMint: Address;
-  amountDebtAtaBalance: Decimal | undefined;
 };
 
 export type BaseLeverageIxsResponse<QuoteResponse> = {
@@ -63,9 +59,7 @@ export type LeverageInitialInputs<LeverageCalcsResult, QuoteResponse> = {
   swapQuote: SwapQuote<QuoteResponse>;
   currentSlot: Slot;
   klendAccounts: Array<Address>;
-  collIsKtoken: boolean;
   obligation: KaminoObligation | ObligationType | undefined;
-  strategy: StrategyWithAddress | undefined;
 };
 
 export interface BaseLeverageSwapInputsProps<QuoteResponse> {
@@ -77,10 +71,8 @@ export interface BaseLeverageSwapInputsProps<QuoteResponse> {
   currentSlot: Slot;
   slippagePct: Decimal;
   budgetAndPriorityFeeIxs?: Instruction[];
-  kamino: Kamino | undefined;
   scopeRefreshConfig?: ScopePriceRefreshConfig;
   quoteBufferBps: Decimal;
-  isKtoken: IsKtokenProvider;
   quoter: SwapQuoteProvider<QuoteResponse>;
   useV2Ixs: boolean;
 }
@@ -94,9 +86,7 @@ export type DepositLeverageInitialInputs<QuoteResponse> = {
   swapQuote: SwapQuote<QuoteResponse>;
   currentSlot: Slot;
   klendAccounts: Array<Address>;
-  collIsKtoken: boolean;
   obligation: KaminoObligation | ObligationType | undefined;
-  strategy: StrategyWithAddress | undefined;
 };
 
 export interface DepositWithLeverageSwapInputsProps<QuoteResponse> extends BaseLeverageSwapInputsProps<QuoteResponse> {
@@ -106,7 +96,6 @@ export interface DepositWithLeverageSwapInputsProps<QuoteResponse> extends BaseL
   priceDebtToColl: Decimal;
   targetLeverage: Decimal;
   selectedTokenMint: Address;
-  priceAinB: PriceAinBProvider;
   // currently only used to disable requesting elevation group when this value is 0
   // to be implemented properly in the future
   elevationGroupOverride?: number;
@@ -123,9 +112,6 @@ export type DepositLeverageCalcsResult = {
   collTokenToDeposit: Decimal;
   swapDebtTokenIn: Decimal;
   swapCollTokenExpectedOut: Decimal;
-  flashBorrowInDebtTokenKtokenOnly: Decimal;
-  singleSidedDepositKtokenOnly: Decimal;
-  requiredCollateralKtokenOnly: Decimal;
 };
 
 export type WithdrawLeverageIxsResponse<QuoteResponse> = BaseLeverageIxsResponse<QuoteResponse> & {
@@ -137,9 +123,7 @@ export type WithdrawLeverageInitialInputs<QuoteResponse> = {
   swapQuote: SwapQuote<QuoteResponse>;
   currentSlot: Slot;
   klendAccounts: Array<Address>;
-  collIsKtoken: boolean;
   obligation: KaminoObligation | ObligationType | undefined;
-  strategy: StrategyWithAddress | undefined;
 };
 
 export interface WithdrawWithLeverageSwapInputsProps<QuoteResponse> extends BaseLeverageSwapInputsProps<QuoteResponse> {
@@ -176,9 +160,7 @@ export type AdjustLeverageInitialInputs<QuoteResponse> = {
   currentSlot: Slot;
   klendAccounts: Array<Address>;
   isDeposit: boolean;
-  collIsKtoken: boolean;
   obligation: KaminoObligation | ObligationType | undefined;
-  strategy: StrategyWithAddress | undefined;
 };
 
 export interface AdjustLeverageSwapInputsProps<QuoteResponse> extends BaseLeverageSwapInputsProps<QuoteResponse> {
@@ -188,7 +170,6 @@ export interface AdjustLeverageSwapInputsProps<QuoteResponse> extends BaseLevera
   targetLeverage: Decimal;
   priceCollToDebt: Decimal;
   priceDebtToColl: Decimal;
-  priceAinB: PriceAinBProvider;
   withdrawSlotOffset?: number;
 }
 
@@ -201,6 +182,5 @@ export type AdjustLeverageCalcsResult = {
   adjustBorrowPosition: Decimal;
   amountToFlashBorrowDebt: Decimal;
   borrowAmount: Decimal;
-  expectedDebtTokenAtaBalance: Decimal;
   withdrawAmountWithSlippageAndFlashLoanFee: Decimal;
 };

package/src/leverage/utils.ts

@@ -1,325 +1,8 @@
-import { Kamino, StrategyWithAddress } from '@kamino-finance/kliquidity-sdk';
-import { KaminoMarket, KaminoReserve, lamportsToNumberDecimal } from '../classes';
-import {
-  Address,
-  Instruction,
-  GetAccountInfoApi,
-  Rpc,
-  GetTokenAccountBalanceApi,
-  TransactionSigner,
-} from '@solana/kit';
+import { KaminoReserve, lamportsToNumberDecimal } from '../classes';
+import { Address, GetAccountInfoApi, Rpc, GetTokenAccountBalanceApi } from '@solana/kit';
 import Decimal from 'decimal.js';
-import { getLookupTableAccounts, getTokenAccountBalanceDecimal } from '../utils';
-import { numberToLamportsDecimal } from '../classes/utils';
+import { getTokenAccountBalanceDecimal } from '../utils';
 import BN from 'bn.js';
-import { PriceAinBProvider, SwapInputs, SwapQuote, SwapIxs, SwapIxsProvider } from './types';
-
-export interface KaminoSwapperIxBuilder {
-  (
-    input: DepositAmountsForSwap,
-    tokenAMint: Address,
-    tokenBMint: Address,
-    owner: TransactionSigner,
-    slippage: Decimal,
-    allKeys: Address[]
-  ): Promise<[Instruction[], Address[]]>;
-}
-
-export interface DepositAmountsForSwap {
-  requiredAAmountToDeposit: Decimal;
-  requiredBAmountToDeposit: Decimal;
-  tokenAToSwapAmount: Decimal;
-  tokenBToSwapAmount: Decimal;
-}
-
-export async function getTokenToKtokenSwapper<QuoteResponse>(
-  kaminoMarket: KaminoMarket,
-  kamino: Kamino,
-  depositor: TransactionSigner,
-  slippagePct: Decimal,
-  swapper: SwapIxsProvider<QuoteResponse>,
-  priceAinB: PriceAinBProvider,
-  includeAtaIxs: boolean = true
-): Promise<SwapIxsProvider<QuoteResponse>> {
-  return async (
-    inputs: SwapInputs,
-    klendAccounts: Array<Address>,
-    quote: SwapQuote<QuoteResponse>
-  ): Promise<Array<SwapIxs<QuoteResponse>>> => {
-    const slippageBps = new Decimal(slippagePct).mul('100');
-    const mintInDecimals = kaminoMarket.getExistingReserveByMint(inputs.inputMint).getMintDecimals();
-    const amountIn = lamportsToNumberDecimal(inputs.inputAmountLamports, mintInDecimals);
-    console.debug('Depositing token', inputs.inputMint, ' for ', inputs.outputMint, 'ktoken');
-    if (inputs.amountDebtAtaBalance === undefined) {
-      throw Error('Amount in debt ATA balance is undefined for leverage ktoken deposit');
-    }
-
-    const ixWithLookup = (await getKtokenDepositIxs(
-      kaminoMarket.getRpc(),
-      kamino,
-      depositor,
-      inputs.inputMint,
-      inputs.outputMint,
-      amountIn,
-      slippageBps,
-      inputs.amountDebtAtaBalance,
-      swapper,
-      priceAinB,
-      includeAtaIxs,
-      klendAccounts,
-      quote
-    ))!;
-
-    const luts = await getLookupTableAccounts(kaminoMarket.getRpc(), ixWithLookup.lookupTablesAddresses);
-
-    return [
-      {
-        preActionIxs: [],
-        swapIxs: ixWithLookup.instructions,
-        lookupTables: luts,
-        // TODO: Ktoken only supports one swap at a time for now (to be updated if we enable ktokens)
-        quote: {
-          priceAInB: new Decimal(0),
-          quoteResponse: undefined,
-        },
-      },
-    ];
-  };
-}
-
-export async function getKtokenDepositIxs<QuoteResponse>(
-  rpc: Rpc<GetAccountInfoApi & GetTokenAccountBalanceApi>,
-  kamino: Kamino,
-  depositor: TransactionSigner,
-  depositTokenMint: Address,
-  ktokenMint: Address,
-  amountToDeposit: Decimal,
-  slippageBps: Decimal,
-  amountExpectedDepositAtaBalance: Decimal,
-  swapper: SwapIxsProvider<QuoteResponse>,
-  priceAinB: PriceAinBProvider,
-  includeAtaIxs: boolean = true,
-  klendAccounts: Array<Address>,
-  quote: SwapQuote<QuoteResponse>
-) {
-  const kaminoStrategy = await kamino.getStrategyByKTokenMint(ktokenMint);
-  const tokenAMint = kaminoStrategy?.strategy.tokenAMint!;
-  const tokenBMint = kaminoStrategy?.strategy.tokenBMint!;
-  const priceAinBDecimal = await priceAinB(tokenAMint, tokenBMint);
-
-  if (tokenAMint === depositTokenMint) {
-    const bBalance = await getTokenAccountBalanceDecimal(rpc, tokenBMint, depositor.address);
-    const tokensBalances = { a: amountExpectedDepositAtaBalance, b: bBalance };
-    console.log('amountToDeposit', amountToDeposit);
-    return await kamino.singleSidedDepositTokenA(
-      kaminoStrategy!,
-      amountToDeposit,
-      depositor,
-      slippageBps,
-      undefined,
-      swapProviderToKaminoSwapProvider(swapper, klendAccounts, quote),
-      tokensBalances,
-      priceAinBDecimal,
-      includeAtaIxs
-    );
-  } else if (tokenBMint === depositTokenMint) {
-    const aBalance = await getTokenAccountBalanceDecimal(rpc, tokenAMint, depositor.address);
-    const tokensBalances = { a: aBalance, b: amountExpectedDepositAtaBalance };
-    return await kamino.singleSidedDepositTokenB(
-      kaminoStrategy!,
-      amountToDeposit,
-      depositor,
-      slippageBps,
-      undefined,
-      swapProviderToKaminoSwapProvider(swapper, klendAccounts, quote),
-      tokensBalances,
-      priceAinBDecimal,
-      includeAtaIxs
-    );
-  } else {
-    throw Error('Deposit token is neither A nor B in the strategy');
-  }
-}
-
-export async function getKtokenToTokenSwapper<QuoteResponse>(
-  kaminoMarket: KaminoMarket,
-  kamino: Kamino,
-  depositor: TransactionSigner,
-  swapper: SwapIxsProvider<QuoteResponse>
-): Promise<SwapIxsProvider<QuoteResponse>> {
-  return async (inputs: SwapInputs, klendAccounts: Array<Address>, quote: SwapQuote<QuoteResponse>) => {
-    const amountInDecimals = kaminoMarket.getExistingReserveByMint(inputs.inputMint).getMintDecimals();
-    const amountToWithdraw = lamportsToNumberDecimal(inputs.inputAmountLamports, amountInDecimals);
-    const kaminoStrategy = await kamino.getStrategyByKTokenMint(inputs.inputMint);
-
-    console.log('Withdrawing ktoken', inputs.inputMint.toString(), ' for ', inputs.outputMint.toString(), 'token');
-
-    const ixWithdraw = (await getKtokenWithdrawIxs(kamino, depositor, kaminoStrategy!, amountToWithdraw))!;
-
-    const [estimatedAOut, estimatedBOut] = await getKtokenWithdrawEstimatesAndPrice(
-      kamino,
-      kaminoStrategy!,
-      amountToWithdraw
-    );
-
-    if (inputs.outputMint === kaminoStrategy!.strategy.tokenAMint!) {
-      const swapArray = await swapper(
-        {
-          inputAmountLamports: estimatedBOut,
-          inputMint: kaminoStrategy!.strategy.tokenBMint!,
-          outputMint: kaminoStrategy!.strategy.tokenAMint!,
-          amountDebtAtaBalance: new Decimal(0),
-        },
-        klendAccounts,
-        quote
-      );
-      // TODO: Ktoken only supports one swap at a time for now (to be updated if we enable ktokens)
-      const swap = swapArray[0];
-
-      return [
-        {
-          preActionIxs: [],
-          swapIxs: [...ixWithdraw.prerequisiteIxs, ixWithdraw.withdrawIx, ...swap.swapIxs],
-          lookupTables: swap.lookupTables,
-          quote: swap.quote,
-        },
-      ];
-    } else if (inputs.outputMint === kaminoStrategy!.strategy.tokenBMint) {
-      const swapArray = await swapper(
-        {
-          inputAmountLamports: estimatedAOut,
-          inputMint: kaminoStrategy!.strategy.tokenAMint!,
-          outputMint: kaminoStrategy!.strategy.tokenBMint!,
-          amountDebtAtaBalance: new Decimal(0),
-        },
-        klendAccounts,
-        quote
-      );
-      // TODO: Ktoken only supports one swap at a time for now (to be updated if we enable ktokens)
-      const swap = swapArray[0];
-
-      return [
-        {
-          preActionIxs: [],
-          swapIxs: [...ixWithdraw.prerequisiteIxs, ixWithdraw.withdrawIx, ...swap.swapIxs],
-          lookupTables: swap.lookupTables,
-          quote: swap.quote,
-        },
-      ];
-    } else {
-      throw Error('Deposit token is neither A nor B in the strategy');
-    }
-  };
-}
-
-export async function getKtokenWithdrawIxs(
-  kamino: Kamino,
-  withdrawer: TransactionSigner,
-  kaminoStrategy: StrategyWithAddress,
-  amountToWithdraw: Decimal
-) {
-  return await kamino.withdrawShares(kaminoStrategy!, amountToWithdraw, withdrawer);
-}
-
-export async function getKtokenWithdrawEstimatesAndPrice(
-  kamino: Kamino,
-  kaminoStrategy: StrategyWithAddress,
-  amountToWithdraw: Decimal
-) {
-  const sharesData = await kamino.getStrategyShareData(kaminoStrategy);
-  const withdrawPct = amountToWithdraw
-    .div(
-      lamportsToNumberDecimal(
-        new Decimal(kaminoStrategy.strategy.sharesIssued.toString()),
-        kaminoStrategy.strategy.sharesMintDecimals.toNumber()
-      )
-    )
-    .toDecimalPlaces(18);
-
-  const withdrawFee = new Decimal(10_000).sub(new Decimal(kaminoStrategy.strategy.withdrawFee.toString()));
-
-  // TODO: Mihai/Marius improve - currently subtracting due to decimal accuracy issues compared to yvaults SC
-  // for both A and B op: .sub(0.000002)
-
-  const estimatedAOut = sharesData.balance.computedHoldings.invested.a
-    .add(sharesData.balance.computedHoldings.available.a)
-    .mul(withdrawPct)
-    .toDecimalPlaces(kaminoStrategy.strategy.tokenAMintDecimals.toNumber(), 1)
-    .sub(0.000002)
-    .mul(withdrawFee)
-    .div(10_000)
-    .toDecimalPlaces(kaminoStrategy.strategy.tokenAMintDecimals.toNumber());
-
-  const estimatedAOutDecimal = numberToLamportsDecimal(
-    estimatedAOut,
-    kaminoStrategy.strategy.tokenAMintDecimals.toNumber()
-  ).floor();
-
-  const estimatedBOut = sharesData.balance.computedHoldings.invested.b
-    .add(sharesData.balance.computedHoldings.available.b)
-    .mul(withdrawPct)
-    .toDecimalPlaces(kaminoStrategy.strategy.tokenBMintDecimals.toNumber(), 1)
-    .sub(0.000002)
-    .mul(withdrawFee)
-    .div(10_000)
-    .toDecimalPlaces(kaminoStrategy.strategy.tokenAMintDecimals.toNumber());
-
-  const estimatedBOutDecimal = numberToLamportsDecimal(
-    estimatedBOut,
-    kaminoStrategy.strategy.tokenBMintDecimals.toNumber()
-  ).floor();
-
-  console.log('a-out', estimatedAOutDecimal.toString());
-  console.log('b-out', estimatedBOut.toString());
-  return [estimatedAOutDecimal, estimatedBOutDecimal];
-}
-
-export function swapProviderToKaminoSwapProvider<QuoteResponse>(
-  swapper: SwapIxsProvider<QuoteResponse>,
-  klendAccounts: Array<Address>,
-  swapQuote: SwapQuote<QuoteResponse>
-): KaminoSwapperIxBuilder {
-  return async (
-    input: DepositAmountsForSwap,
-    tokenAMint: Address,
-    tokenBMint: Address,
-    _owner: TransactionSigner,
-    _slippage: Decimal,
-    _allKeys: Address[]
-  ): Promise<[Instruction[], Address[]]> => {
-    if (input.tokenBToSwapAmount.lt(0)) {
-      const swapperIxsArray = await swapper(
-        {
-          inputAmountLamports: input.tokenBToSwapAmount.abs(),
-          inputMint: tokenBMint,
-          outputMint: tokenAMint,
-          amountDebtAtaBalance: undefined,
-        },
-        klendAccounts,
-        swapQuote
-      );
-      // TODO: Ktoken only supports one swap at a time for now (to be updated if we enable ktokens)
-      const swapperIxs = swapperIxsArray[0];
-      return [swapperIxs.swapIxs, swapperIxs.lookupTables.map((lt) => lt.address)];
-    } else if (input.tokenAToSwapAmount.lt(0)) {
-      const swapperIxsArray = await swapper(
-        {
-          inputAmountLamports: input.tokenAToSwapAmount.abs(),
-          inputMint: tokenAMint,
-          outputMint: tokenBMint,
-          amountDebtAtaBalance: undefined,
-        },
-        klendAccounts,
-        swapQuote
-      );
-      // TODO: Ktoken only supports one swap at a time for now (to be updated if we enable ktokens)
-      const swapperIxs = swapperIxsArray[0];
-      return [swapperIxs.swapIxs, swapperIxs.lookupTables.map((lt) => lt.address)];
-    } else {
-      throw Error('Nothing to swap');
-    }
-  };
-}
 
 export const getExpectedTokenBalanceAfterBorrow = async (
   rpc: Rpc<GetAccountInfoApi & GetTokenAccountBalanceApi>,

package/src/lib.ts

@@ -8,6 +8,7 @@ export * from './@codegen/kvault/instructions';
 export * from './@codegen/kvault/accounts/VaultState';
 export * from './@codegen/kvault/types';
 export { PROGRAM_ID as KVAULTS_PROGRAM_ID } from './@codegen/kvault/programId';
+export { PROGRAM_ID as UNSTAKING_POOL_ID } from './@codegen/unstaking_pool/programId';
 
 export * from './classes';
 export * from './utils';

package/src/utils/lookupTable.ts

@@ -7,6 +7,8 @@ import {
   getDeactivateLookupTableInstruction,
   getExtendLookupTableInstruction,
 } from '@solana-program/address-lookup-table';
+import { DEFAULT_PUBLIC_KEY } from './pubkey';
+import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
 
 export async function printAddressLookupTable(rpc: Rpc<GetAccountInfoApi>, lookupTablePk: Address): Promise<void> {
   const lookupTableAccount = (await fetchAddressLookupTable(rpc, lookupTablePk)).data;
@@ -114,3 +116,49 @@ export async function getAccountsInLut(rpc: Rpc<GetAccountInfoApi>, lookupTable:
   const lutState = await fetchAddressLookupTable(rpc, lookupTable);
   return lutState.data.addresses;
 }
+/**
+ * This method inserts the missing keys from the provided keys into an existent lookup table
+ * @param authority - payer wallet pubkey
+ * @param lookupTable - lookup table to insert the keys into
+ * @param keys - keys to insert into the lookup table
+ * @param [accountsInLut] - the existent accounts in the lookup table. Optional. If provided, the function will not fetch the accounts in the lookup table
+ * @returns - an array of instructions to insert the missing keys into the lookup table
+ */
+export async function insertIntoLookupTableIxs(
+  rpc: Rpc<GetAccountInfoApi>,
+  authority: TransactionSigner,
+  lookupTable: Address,
+  keys: Address[],
+  accountsInLut?: Address[]
+): Promise<Instruction[]> {
+  let lutContentsList = accountsInLut;
+  if (!accountsInLut) {
+    lutContentsList = await getAccountsInLut(rpc, lookupTable);
+  } else {
+    lutContentsList = accountsInLut;
+  }
+
+  const lutContents = new Set<Address>(lutContentsList);
+
+  const missingAccounts = keys.filter((key) => !lutContents.has(key) && key !== DEFAULT_PUBLIC_KEY);
+  // deduplicate missing accounts and remove default accounts and convert it back to an array
+  const missingAccountsList = [...new Set<Address>(missingAccounts)];
+
+  const chunkSize = 20;
+  const ixs: Instruction[] = [];
+
+  for (let i = 0; i < missingAccountsList.length; i += chunkSize) {
+    const chunk = missingAccountsList.slice(i, i + chunkSize);
+    ixs.push(
+      getExtendLookupTableInstruction({
+        payer: authority,
+        authority,
+        address: lookupTable,
+        systemProgram: SYSTEM_PROGRAM_ADDRESS,
+        addresses: chunk,
+      })
+    );
+  }
+
+  return ixs;
+}