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

package/src/classes/manager.ts

@@ -1566,6 +1566,17 @@ export const MARKET_UPDATER = new ConfigUpdater(UpdateLendingMarketMode.fromDeco
   [UpdateLendingMarketMode.UpdateInitialDepositAmount.kind]: config.minInitialDepositAmount,
   [UpdateLendingMarketMode.UpdateObligationOrderCreationEnabled.kind]: config.obligationOrderCreationEnabled,
   [UpdateLendingMarketMode.UpdateObligationOrderExecutionEnabled.kind]: config.obligationOrderExecutionEnabled,
+  [UpdateLendingMarketMode.UpdateMatureReserveDebtLiquidationEnabled.kind]: config.matureReserveDebtLiquidationEnabled,
+  [UpdateLendingMarketMode.UpdateObligationBorrowDebtTermLiquidationEnabled.kind]:
+    config.obligationBorrowDebtTermLiquidationEnabled,
+  [UpdateLendingMarketMode.UpdateProposerAuthority.kind]: config.proposerAuthority,
+  [UpdateLendingMarketMode.UpdateBorrowOrderCreationEnabled.kind]: config.borrowOrderCreationEnabled,
+  [UpdateLendingMarketMode.UpdateBorrowOrderExecutionEnabled.kind]: config.borrowOrderExecutionEnabled,
+  [UpdateLendingMarketMode.UpdatePriceTriggeredLiquidationDisabled.kind]: config.priceTriggeredLiquidationDisabled,
+  [UpdateLendingMarketMode.UpdateUnstakingPoolState.kind]: config.unstakingPoolState,
+  [UpdateLendingMarketMode.UpdateWithdrawTicketIssuanceEnabled.kind]: config.withdrawTicketIssuanceEnabled,
+  [UpdateLendingMarketMode.UpdateWithdrawTicketRedemptionEnabled.kind]: config.withdrawTicketRedemptionEnabled,
+  [UpdateLendingMarketMode.UpdateMinWithdrawQueuedLiquidityValue.kind]: config.minWithdrawQueuedLiquidityValue,
 }));
 
 function parseForChangesMarketConfigAndGetIxs(

package/src/classes/market.ts

@@ -54,6 +54,8 @@ import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
 import { ObligationZP } from '../@codegen/klend/zero_padding';
 import { checkDefined } from '../utils/validations';
 import { Buffer } from 'buffer';
+import { UNSTAKING_POOL_STAGING_ID, unstakingPoolMintPda } from './unstakingPool';
+import { PROGRAM_ID as UNSTAKING_POOL_ID } from '../@codegen/unstaking_pool/programId';
 
 export type KaminoMarketRpcApi = GetAccountInfoApi &
   GetMultipleAccountsApi &
@@ -64,6 +66,9 @@ export type KaminoMarketRpcApi = GetAccountInfoApi &
   GetBalanceApi;
 
 const base58Decoder = getBase58Decoder();
+// This is a list of reserves (for STAGING only) that were incorrectly initialized and mess up with the mapping from mint -> reserve
+// This can be removed once we migrate all ixs to act upon reserve pubkey instead of mints
+export const INCORRECT_RESERVES_STAGING: Address[] = [address('5JPmNb5oxRZF4yp3kQL44HWmZnbyjguRVZbo2ew6FoxV')];
 
 export interface ReserveRewardInfo {
   rewardsPerSecond: Decimal; // not lamport
@@ -230,8 +235,15 @@ export class KaminoMarket {
     this.reservesActive = getReservesActive(this.reserves);
   }
 
-  async reloadSingleReserve(reservePk: Address, reserveData?: Reserve): Promise<void> {
-    const reserve = await getSingleReserve(reservePk, this.rpc, this.recentSlotDurationMs, reserveData);
+  async reloadSingleReserve(reservePk: Address, reserveData?: Reserve, programId: Address = PROGRAM_ID): Promise<void> {
+    const reserve = await getSingleReserve(
+      reservePk,
+      this.rpc,
+      this.recentSlotDurationMs,
+      reserveData,
+      undefined,
+      programId
+    );
     this.reserves.set(reservePk, reserve);
     this.reservesActive.set(reservePk, reserve);
   }
@@ -244,6 +256,20 @@ export class KaminoMarket {
     return this.address;
   }
 
+  getUsolPoolAddress(): Address {
+    return this.state.unstakingPoolState;
+  }
+
+  getUsolPoolProgramId(): Address {
+    return this.programId == PROGRAM_ID ? UNSTAKING_POOL_ID : UNSTAKING_POOL_STAGING_ID;
+  }
+
+  async getUsolPoolMint(): Promise<Address> {
+    const usolPoolPk = this.getUsolPoolAddress();
+    const usolPoolProgram = this.getUsolPoolProgramId();
+    return (await unstakingPoolMintPda(usolPoolPk, usolPoolProgram))[0];
+  }
+
   /**
    * Get a list of reserves for this market
    */
@@ -1584,7 +1610,7 @@ export async function getReservesForMarket(
   recentSlotDurationMs: number,
   oracleAccounts?: AllOracleAccounts
 ): Promise<Map<Address, KaminoReserve>> {
-  const reserves = await rpc
+  let reserves = await rpc
     .getProgramAccounts(programId, {
       filters: [
         {
@@ -1601,6 +1627,10 @@ export async function getReservesForMarket(
       encoding: 'base64',
     })
     .send();
+  // If staging env always filter the incorrect reserves
+  if (programId !== PROGRAM_ID) {
+    reserves = reserves.filter((reserve) => INCORRECT_RESERVES_STAGING.includes(reserve.pubkey) === false);
+  }
   const deserializedReserves: ReserveWithAddress[] = reserves.map((reserve) => {
     if (reserve.account === null) {
       throw new Error(`Reserve account ${reserve.pubkey} does not exist`);
@@ -1637,9 +1667,10 @@ export async function getSingleReserve(
   rpc: Rpc<KaminoReserveRpcApi>,
   recentSlotDurationMs: number,
   reserveData?: Reserve,
-  oracleAccounts?: AllOracleAccounts
+  oracleAccounts?: AllOracleAccounts,
+  programId: Address = PROGRAM_ID
 ): Promise<KaminoReserve> {
-  const reserve = reserveData ?? (await Reserve.fetch(rpc, reservePk));
+  const reserve = reserveData ?? (await Reserve.fetch(rpc, reservePk, programId));
 
   if (reserve === null) {
     throw new Error(`Reserve account ${reservePk} does not exist`);

package/src/classes/obligation.ts

@@ -270,7 +270,7 @@ export class KaminoObligation {
    * Returns obligation orders (including the null ones, i.e. non-active positions in the orders' array).
    */
   getOrders(): Array<KaminoObligationOrder | null> {
-    return this.state.orders.map((order) => KaminoObligationOrder.fromState(order));
+    return this.state.obligationOrders.map((order) => KaminoObligationOrder.fromState(order));
   }
 
   /**

package/src/classes/reserve.ts

@@ -144,7 +144,7 @@ export class KaminoReserve {
    * @returns the available liquidity amount of the reserve in lamports
    */
   getLiquidityAvailableAmount(): Decimal {
-    return new Decimal(this.state.liquidity.availableAmount.toString());
+    return new Decimal(this.state.liquidity.totalAvailableAmount.toString());
   }
 
   /**
@@ -199,7 +199,7 @@ export class KaminoReserve {
    * @returns the origination fee percentage of the reserve
    */
   getBorrowFee = (): Decimal => {
-    return new Fraction(this.state.config.fees.borrowFeeSf).toDecimal();
+    return new Fraction(this.state.config.fees.originationFeeSf).toDecimal();
   };
 
   /**
@@ -1163,13 +1163,12 @@ export async function createReserveIxs(
 
   const { liquiditySupplyVault, collateralMint, collateralSupplyVault, feeVault } = await reservePdas(
     programId,
-    lendingMarket,
-    liquidityMint
+    reserveAddress.address
   );
   const [lendingMarketAuthority] = await lendingMarketAuthPda(lendingMarket, programId);
 
   const accounts: InitReserveAccounts = {
-    lendingMarketOwner: owner,
+    signer: owner,
     lendingMarket: lendingMarket,
     lendingMarketAuthority: lendingMarketAuthority,
     reserve: reserveAddress.address,
@@ -1222,7 +1221,7 @@ export const RESERVE_CONFIG_UPDATER = new ConfigUpdater(UpdateConfigMode.fromDec
   [UpdateConfigMode.UpdateLiquidationThresholdPct.kind]: config.liquidationThresholdPct,
   [UpdateConfigMode.UpdateProtocolLiquidationFee.kind]: config.protocolLiquidationFeePct,
   [UpdateConfigMode.UpdateProtocolTakeRate.kind]: config.protocolTakeRatePct,
-  [UpdateConfigMode.UpdateFeesBorrowFee.kind]: config.fees.borrowFeeSf,
+  [UpdateConfigMode.UpdateFeesOriginationFee.kind]: config.fees.originationFeeSf,
   [UpdateConfigMode.UpdateFeesFlashLoanFee.kind]: config.fees.flashLoanFeeSf,
   [UpdateConfigMode.DeprecatedUpdateFeesReferralFeeBps.kind]: [], // deprecated
   [UpdateConfigMode.UpdateDepositLimit.kind]: config.depositLimit,
@@ -1256,7 +1255,7 @@ export const RESERVE_CONFIG_UPDATER = new ConfigUpdater(UpdateConfigMode.fromDec
   [UpdateConfigMode.UpdateMinLiquidationBonusBps.kind]: config.minLiquidationBonusBps,
   [UpdateConfigMode.UpdateDeleveragingMarginCallPeriod.kind]: config.deleveragingMarginCallPeriodSecs,
   [UpdateConfigMode.UpdateBorrowFactor.kind]: config.borrowFactorPct,
-  [UpdateConfigMode.UpdateAssetTier.kind]: config.assetTier,
+  [UpdateConfigMode.DeprecatedUpdateAssetTier.kind]: [], //deprecated
   [UpdateConfigMode.UpdateElevationGroup.kind]: config.elevationGroups,
   [UpdateConfigMode.UpdateDeleveragingThresholdDecreaseBpsPerDay.kind]: config.deleveragingThresholdDecreaseBpsPerDay,
   [UpdateConfigMode.DeprecatedUpdateMultiplierSideBoost.kind]: [], // deprecated
@@ -1274,6 +1273,12 @@ export const RESERVE_CONFIG_UPDATER = new ConfigUpdater(UpdateConfigMode.fromDec
   [UpdateConfigMode.UpdateAutodeleverageEnabled.kind]: config.autodeleverageEnabled,
   [UpdateConfigMode.UpdateDeleveragingBonusIncreaseBpsPerDay.kind]: config.deleveragingBonusIncreaseBpsPerDay,
   [UpdateConfigMode.UpdateProtocolOrderExecutionFee.kind]: config.protocolOrderExecutionFeePct,
+  [UpdateConfigMode.UpdateDebtMaturityTimestamp.kind]: config.debtMaturityTimestamp,
+  [UpdateConfigMode.UpdateDebtTermSeconds.kind]: config.debtTermSeconds,
+  [UpdateConfigMode.UpdateProposerAuthorityLock.kind]: config.proposerAuthorityLocked,
+  [UpdateConfigMode.UpdateMinDeleveragingBonusBps.kind]: config.minDeleveragingBonusBps,
+  [UpdateConfigMode.UpdateCanUnstakeLstCollateral.kind]: config.canUnstakeLstCollateral,
+  [UpdateConfigMode.UpdateLtvLamportsMargin.kind]: config.ltvLamportsMargin,
 }));
 
 export async function updateEntireReserveConfigIx(
@@ -1345,7 +1350,7 @@ const NON_VALIDATED_DISCRIMINATORS = [
 function shouldSkipValidation(mode: UpdateConfigModeKind, reserve: Reserve | undefined): boolean {
   return (
     NON_VALIDATED_DISCRIMINATORS.includes(mode.discriminator) &&
-    !reserve?.liquidity.availableAmount.gten(MIN_INITIAL_DEPOSIT)
+    !reserve?.liquidity.totalAvailableAmount.gten(MIN_INITIAL_DEPOSIT)
   );
 }
 

package/src/classes/unstakingPool.ts

@@ -17,6 +17,7 @@ import { TOKEN_2022_PROGRAM_ADDRESS } from '@solana-program/token-2022';
 import { getAssociatedTokenAddress } from '../lib';
 import { PoolState, UnstakeTicket } from '../@codegen/unstaking_pool/accounts';
 import {
+  createAssociatedTokenAccountIdempotentInstruction,
   createLookupTableIx,
   DEFAULT_PUBLIC_KEY,
   extendLookupTableIxs,
@@ -49,6 +50,7 @@ import {
   Rpc,
   SolanaRpcApi,
   TransactionSigner,
+  getBase58Decoder,
 } from '@solana/kit';
 import { getCreateAccountInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
 import { SYSVAR_CLOCK_ADDRESS, SYSVAR_INSTRUCTIONS_ADDRESS, SYSVAR_RENT_ADDRESS } from '@solana/sysvars';
@@ -62,16 +64,29 @@ const STAKE_HISTORY_PROGRAM_ID: Address = address('SysvarStakeHistory11111111111
 const STAKE_ACCOUNT_SIZE: number = 200;
 export const STAKE_POOL_SIZE: number = 611;
 const addressEncoder = getAddressEncoder();
+const base58Decoder = getBase58Decoder();
 
 /**
  * Unstaking sol mint seed
  */
 export const UNSTAKING_SOL_MINT_SEED = Buffer.from('unstaking_sol_mint');
 
+/**
+ * Unstaking sol mint seed
+ */
+export const UNSTAKING_SOL_WSOL_VAULT_SEED = Buffer.from('wsol_vault');
+
 /**
  * Unstaking sol pool base authority seed
  */
-export const BASE_POOL_AUTHORITY_SEED = Buffer.from('authority');
+export const BASE_POOL_AUTHORITY_SEED = Buffer.from('base_authority');
+
+/**
+ * Unstaking sol pool lending market authority seed
+ */
+export const UNSTAKING_POOL_AUTHORITY_SEED = Buffer.from('upa');
+
+/**
 
 /**
  * KaminoPoolClient is a class that provides a high-level interface to interact with the Kamino Pool program.
@@ -112,8 +127,8 @@ export class UnstakingPoolClient {
     });
 
     const unstakingSolMint = (await unstakingPoolMintPda(poolState.address))[0];
-    const basePoolAuthority = (await unstakingPoolAuthorityPda(poolState.address))[0];
-    const wsolVault = await getAssociatedTokenAddress(WRAPPED_SOL_MINT, basePoolAuthority);
+    const basePoolAuthority = (await unstakingPoolBaseAuthorityPda(poolState.address))[0];
+    const wsolVault = (await unstakingPoolWsolVaultPda(poolState.address))[0];
 
     const initPoolAccounts: InitializePoolAccounts = {
       admin: poolConfig.admin,
@@ -276,6 +291,7 @@ export class UnstakingPoolClient {
    * @param stakedSolMint - staked sol mint
    * @param stakedSolToDeposit - staked sol to convert to USOL (at the pool ratio)
    * @param minSharesToReceive - parameter to control slippage
+   * @param initUsolAta - pass if you want the usol ata initialized
    * @returns burn instruction
    */
   async mintIx(
@@ -285,7 +301,8 @@ export class UnstakingPoolClient {
     unstakeTicket: TransactionSigner,
     stakedSolMint: Address,
     stakedSolToDeposit: BN,
-    minSharesToReceive: BN
+    minSharesToReceive: BN,
+    initUsolAta: boolean
   ): Promise<MintIxs> {
     const pool = await poolState.getState(this.getConnection());
     // Create unstake ticket ix
@@ -340,7 +357,17 @@ export class UnstakingPoolClient {
       accounts: ixAccounts.concat(remainingAccounts),
       data: ix.data,
     };
-    return { mintIxs: [createUnstakeTicketIx, mintIx], additionalSigners: remainingSigners };
+    const ixs = [createUnstakeTicketIx, mintIx];
+    if (initUsolAta) {
+      const [_, createAtaIx] = await createAssociatedTokenAccountIdempotentInstruction(
+        user,
+        pool.unstakingSolMint,
+        user.address,
+        TOKEN_PROGRAM_ADDRESS
+      );
+      ixs.splice(1, 0, createAtaIx);
+    }
+    return { mintIxs: ixs, additionalSigners: remainingSigners };
   }
 
   /**
@@ -467,6 +494,46 @@ export class UnstakingPool {
   }
 }
 
+export async function getAllTicketsForUser(
+  rpc: Rpc<GetProgramAccountsApi>,
+  user: Address,
+  programId: Address = UNSTAKING_POOL_ID
+): Promise<Array<UnstakeTicketInfo>> {
+  const results = await rpc
+    .getProgramAccounts(programId, {
+      filters: [
+        {
+          dataSize: BigInt(UnstakeTicket.layout.span + 8),
+        },
+        {
+          memcmp: {
+            offset: 0n,
+            bytes: base58Decoder.decode(UnstakeTicket.discriminator) as Base58EncodedBytes,
+            encoding: 'base58',
+          },
+        },
+        {
+          memcmp: {
+            offset: 8n,
+            bytes: user.toString() as Base58EncodedBytes,
+            encoding: 'base58',
+          },
+        },
+      ],
+      encoding: 'base64',
+    })
+    .send();
+
+  return results.map((result) => {
+    return { state: UnstakeTicket.decode(Buffer.from(result.account.data[0], 'base64')), pk: result.pubkey };
+  });
+}
+
+export type UnstakeTicketInfo = {
+  pk: Address;
+  state: UnstakeTicket;
+};
+
 export type StakeAccountInfo = {
   pk: Address;
   stakeAccount: StakeAccount;
@@ -493,7 +560,17 @@ export function unstakingPoolMintPda(
   });
 }
 
-export function unstakingPoolAuthorityPda(
+export function unstakingPoolWsolVaultPda(
+  pool: Address,
+  programId: Address = UNSTAKING_POOL_ID
+): Promise<ProgramDerivedAddress> {
+  return getProgramDerivedAddress({
+    seeds: [UNSTAKING_SOL_WSOL_VAULT_SEED, addressEncoder.encode(pool)],
+    programAddress: programId,
+  });
+}
+
+export function unstakingPoolBaseAuthorityPda(
   pool: Address,
   programId: Address = UNSTAKING_POOL_ID
 ): Promise<ProgramDerivedAddress> {