@kamino-finance/klend-sdk 7.1.2 → 7.1.4-beta.0

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/manager/client_kamino_manager.ts

@@ -1991,11 +1991,10 @@ function parseReserveConfigFromFile(reserveConfigFromFile: any): ReserveConfig {
     protocolLiquidationFeePct: reserveConfigFromFile.protocolLiquidationFeePct,
     protocolOrderExecutionFeePct: reserveConfigFromFile.protocolOrderExecutionFeePct,
     protocolTakeRatePct: reserveConfigFromFile.protocolTakeRatePct,
-    assetTier: reserveConfigFromFile.assetTier,
     maxLiquidationBonusBps: reserveConfigFromFile.maxLiquidationBonusBps,
     badDebtLiquidationBonusBps: reserveConfigFromFile.badDebtLiquidationBonusBps,
     fees: {
-      borrowFeeSf: Fraction.fromDecimal(new Decimal(reserveConfigFromFile.fees.borrowFee)).valueSf,
+      originationFeeSf: Fraction.fromDecimal(new Decimal(reserveConfigFromFile.fees.borrowFee)).valueSf,
       flashLoanFeeSf: Fraction.fromDecimal(new Decimal(reserveConfigFromFile.fees.flashLoanFee)).valueSf,
       padding: Array(8).fill(0),
     },
@@ -2040,8 +2039,14 @@ function parseReserveConfigFromFile(reserveConfigFromFile: any): ReserveConfig {
     borrowLimitOutsideElevationGroup: new BN(reserveConfigFromFile.borrowLimitOutsideElevationGroup),
     borrowLimitAgainstThisCollateralInElevationGroup: parseReserveBorrowLimitAgainstCollInEmode(reserveConfigFromFile),
     deleveragingBonusIncreaseBpsPerDay: new BN(reserveConfigFromFile.deleveragingBonusIncreaseBpsPerDay),
-    reserved1: Array(1).fill(0),
-    reserved2: Array(9).fill(0),
+    canUnstakeLstCollateral: reserveConfigFromFile.canUnstakeLstCollateral,
+    debtMaturityTimestamp: new BN(reserveConfigFromFile.debtMaturityTimestamp),
+    debtTermSeconds: new BN(reserveConfigFromFile.debtTermSeconds),
+    minDeleveragingBonusBps: reserveConfigFromFile.minDeleveragingBonusBps,
+    proposerAuthorityLocked: reserveConfigFromFile.proposerAuthorityLocked,
+    reserved1: Array(6).fill(0),
+    paddingDeprecatedAssetTier: 0,
+    ltvLamportsMargin: new BN(0),
   };
 
   return new ReserveConfig(reserveConfigFields);
@@ -2121,11 +2126,10 @@ function parseReserveConfigToFile(reserveConfig: ReserveConfig) {
     protocolLiquidationFeePct: reserveConfig.protocolLiquidationFeePct,
     protocolOrderExecutionFeePct: reserveConfig.protocolOrderExecutionFeePct,
     protocolTakeRatePct: reserveConfig.protocolTakeRatePct,
-    assetTier: reserveConfig.assetTier,
     maxLiquidationBonusBps: reserveConfig.maxLiquidationBonusBps,
     badDebtLiquidationBonusBps: reserveConfig.badDebtLiquidationBonusBps,
     fees: {
-      borrowFee: new Fraction(reserveConfig.fees.borrowFeeSf).toDecimal().toString(),
+      borrowFee: new Fraction(reserveConfig.fees.originationFeeSf).toDecimal().toString(),
       flashLoanFee: new Fraction(reserveConfig.fees.flashLoanFeeSf).toDecimal().toString(),
       padding: Array(8).fill(0),
     },
@@ -2161,8 +2165,7 @@ function parseReserveConfigToFile(reserveConfig: ReserveConfig) {
     borrowLimitAgainstThisCollateralInElevationGroup:
       reserveConfig.borrowLimitAgainstThisCollateralInElevationGroup.map((entry) => entry.toString()),
     deleveragingBonusIncreaseBpsPerDay: reserveConfig.deleveragingBonusIncreaseBpsPerDay.toString(),
-    reserved1: Array(2).fill(0),
-    reserved2: Array(9).fill(0),
+    reserved1: Array(6).fill(0),
   };
 }
 

package/src/utils/managerTypes.ts

@@ -306,11 +306,10 @@ function buildReserveConfig(fields: {
     protocolLiquidationFeePct: 0,
     protocolOrderExecutionFeePct: 0,
     protocolTakeRatePct: fields.configParams.protocolTakeRate,
-    assetTier: 0,
     maxLiquidationBonusBps: fields.configParams.maxLiquidationBonusBps,
     badDebtLiquidationBonusBps: fields.configParams.badDebtLiquidationBonusBps,
     fees: {
-      borrowFeeSf: fields.configParams.borrowFeeSf.getValue(),
+      originationFeeSf: fields.configParams.borrowFeeSf.getValue(),
       flashLoanFeeSf: fields.configParams.flashLoanFeeSf.getValue(),
       padding: Array(6).fill(0),
     },
@@ -369,8 +368,14 @@ function buildReserveConfig(fields: {
     ),
     borrowLimitAgainstThisCollateralInElevationGroup: Array(32).fill(new BN(0)),
     deleveragingBonusIncreaseBpsPerDay: new BN(100),
-    reserved1: Array(1).fill(0),
-    reserved2: Array(9).fill(0),
+    canUnstakeLstCollateral: 0,
+    debtMaturityTimestamp: new BN(0),
+    debtTermSeconds: new BN(0),
+    minDeleveragingBonusBps: 0,
+    proposerAuthorityLocked: 0,
+    ltvLamportsMargin: new BN(0),
+    reserved1: Array(6).fill(0),
+    paddingDeprecatedAssetTier: 0,
   };
 
   return new ReserveConfig(reserveConfigFields);

package/src/utils/seeds.ts

@@ -3,6 +3,7 @@ import { PROGRAM_ID } from '../@codegen/klend/programId';
 import { PROGRAM_ID as FARMS_PROGRAM_ID } from '@kamino-finance/farms-sdk/dist/@codegen/farms/programId';
 import { METADATA_PROGRAM_ID, METADATA_SEED } from '../classes/vault';
 import { Buffer } from 'buffer';
+import { UNSTAKING_POOL_AUTHORITY_SEED } from '../classes/unstakingPool';
 
 /**
  * Lending market authority seed
@@ -69,16 +70,15 @@ export interface ReservePdas {
 /**
  * Returns all the PDAs for the given reserve
  * @param programId
- * @param market
- * @param mint
+ * @param reserve
  * @returns ReservePdas
  */
-export async function reservePdas(programId: Address, market: Address, mint: Address): Promise<ReservePdas> {
+export async function reservePdas(programId: Address, reserve: Address): Promise<ReservePdas> {
   const [[liquiditySupplyVault], [collateralMint], [collateralSupplyVault], [feeVault]] = await Promise.all([
-    reserveLiqSupplyPda(market, mint, programId),
-    reserveCollateralMintPda(market, mint, programId),
-    reserveCollateralSupplyPda(market, mint, programId),
-    reserveFeeVaultPda(market, mint, programId),
+    reserveLiqSupplyPda(reserve, programId),
+    reserveCollateralMintPda(reserve, programId),
+    reserveCollateralSupplyPda(reserve, programId),
+    reserveFeeVaultPda(reserve, programId),
   ]);
   return {
     liquiditySupplyVault,
@@ -107,71 +107,63 @@ export function lendingMarketAuthPda(
 /**
  * Returns the PDA and bump for the reserve liquidity supply
  * @param lendingMarket
- * @param mint
  * @param programId
  * @returns [pda, bump]
  */
 export async function reserveLiqSupplyPda(
-  lendingMarket: Address,
-  mint: Address,
+  reserve: Address,
   programId: Address = PROGRAM_ID
 ): Promise<ProgramDerivedAddress> {
   return getProgramDerivedAddress({
-    seeds: [Buffer.from(RESERVE_LIQ_SUPPLY_SEED), addressEncoder.encode(lendingMarket), addressEncoder.encode(mint)],
+    seeds: [Buffer.from(RESERVE_LIQ_SUPPLY_SEED), addressEncoder.encode(reserve)],
     programAddress: programId,
   });
 }
 
 /**
  * Returns the PDA and bump for the reserve fee vault
- * @param lendingMarket
- * @param mint
+ * @param reserve
  * @param programId
  * @returns [vaultPda, bump]
  */
 export async function reserveFeeVaultPda(
-  lendingMarket: Address,
-  mint: Address,
+  reserve: Address,
   programId: Address = PROGRAM_ID
 ): Promise<ProgramDerivedAddress> {
   return getProgramDerivedAddress({
-    seeds: [Buffer.from(FEE_RECEIVER_SEED), addressEncoder.encode(lendingMarket), addressEncoder.encode(mint)],
+    seeds: [Buffer.from(FEE_RECEIVER_SEED), addressEncoder.encode(reserve)],
     programAddress: programId,
   });
 }
 
 /**
  * Returns the PDA and bump for the reserve collateral mint
- * @param lendingMarket
- * @param mint
+ * @param reserve
  * @param programId
  * @returns [mintPda, bump]
  */
 export async function reserveCollateralMintPda(
-  lendingMarket: Address,
-  mint: Address,
+  reserve: Address,
   programId: Address = PROGRAM_ID
 ): Promise<ProgramDerivedAddress> {
   return getProgramDerivedAddress({
-    seeds: [Buffer.from(RESERVE_COLL_MINT_SEED), addressEncoder.encode(lendingMarket), addressEncoder.encode(mint)],
+    seeds: [Buffer.from(RESERVE_COLL_MINT_SEED), addressEncoder.encode(reserve)],
     programAddress: programId,
   });
 }
 
 /**
  * Returns the PDA and bump for the reserve collateral supply
- * @param lendingMarket
- * @param mint
+ * @param reserve
  * @param programId
  * @returns [pda, bump]
  */
 export function reserveCollateralSupplyPda(
-  lendingMarket: Address,
-  mint: Address,
+  reserve: Address,
   programId: Address = PROGRAM_ID
 ): Promise<ProgramDerivedAddress> {
   return getProgramDerivedAddress({
-    seeds: [Buffer.from(RESERVE_COLL_SUPPLY_SEED), addressEncoder.encode(lendingMarket), addressEncoder.encode(mint)],
+    seeds: [Buffer.from(RESERVE_COLL_SUPPLY_SEED), addressEncoder.encode(reserve)],
     programAddress: programId,
   });
 }
@@ -290,3 +282,13 @@ export async function getKVaultSharesMetadataPda(mint: Address): Promise<Program
     programAddress: METADATA_PROGRAM_ID,
   });
 }
+
+export function unstakingPoolMarketAuthorityPda(
+  lendingMarket: Address,
+  programId: Address = PROGRAM_ID
+): Promise<ProgramDerivedAddress> {
+  return getProgramDerivedAddress({
+    seeds: [UNSTAKING_POOL_AUTHORITY_SEED, addressEncoder.encode(lendingMarket)],
+    programAddress: programId,
+  });
+}

package/dist/@codegen/klend/types/AssetTier.d.ts

@@ -1,45 +0,0 @@
-import * as types from "../types";
-import * as borsh from "@coral-xyz/borsh";
-export interface RegularJSON {
-    kind: "Regular";
-}
-export declare class Regular {
-    static readonly discriminator = 0;
-    static readonly kind = "Regular";
-    readonly discriminator = 0;
-    readonly kind = "Regular";
-    toJSON(): RegularJSON;
-    toEncodable(): {
-        Regular: {};
-    };
-}
-export interface IsolatedCollateralJSON {
-    kind: "IsolatedCollateral";
-}
-export declare class IsolatedCollateral {
-    static readonly discriminator = 1;
-    static readonly kind = "IsolatedCollateral";
-    readonly discriminator = 1;
-    readonly kind = "IsolatedCollateral";
-    toJSON(): IsolatedCollateralJSON;
-    toEncodable(): {
-        IsolatedCollateral: {};
-    };
-}
-export interface IsolatedDebtJSON {
-    kind: "IsolatedDebt";
-}
-export declare class IsolatedDebt {
-    static readonly discriminator = 2;
-    static readonly kind = "IsolatedDebt";
-    readonly discriminator = 2;
-    readonly kind = "IsolatedDebt";
-    toJSON(): IsolatedDebtJSON;
-    toEncodable(): {
-        IsolatedDebt: {};
-    };
-}
-export declare function fromDecoded(obj: any): types.AssetTierKind;
-export declare function fromJSON(obj: types.AssetTierJSON): types.AssetTierKind;
-export declare function layout(property?: string): borsh.EnumLayout<unknown>;
-//# sourceMappingURL=AssetTier.d.ts.map