@kamino-finance/klend-sdk 5.14.4 → 5.15.0

package/src/classes/market.ts

@@ -524,13 +524,9 @@ export class KaminoMarket {
         getRewardPrice
       );
     }
-    
+
     if (isNotNullPubkey(debtFarmAddress)) {
-      result.borrowingRewards = await this.getRewardInfoForFarm(
-        debtFarmAddress, 
-        totalBorrowAmount, 
-        getRewardPrice
-      );
+      result.borrowingRewards = await this.getRewardInfoForFarm(debtFarmAddress, totalBorrowAmount, getRewardPrice);
     }
 
     return result;

package/src/classes/reserve.ts

@@ -9,6 +9,7 @@ import {
 } from '@solana/web3.js';
 import Decimal from 'decimal.js';
 import {
+  globalConfigPda,
   INITIAL_COLLATERAL_RATE,
   lendingMarketAuthPda,
   MarketWithAddress,
@@ -39,7 +40,6 @@ import {
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { aprToApy, KaminoPrices } from '@kamino-finance/kliquidity-sdk';
 import { FarmState, RewardInfo } from '@kamino-finance/farms-sdk';
-import BN from 'bn.js';
 
 export const DEFAULT_RECENT_SLOT_DURATION_MS = 450;
 
@@ -1180,18 +1180,20 @@ export function updateReserveConfigIx(
   mode: UpdateConfigModeKind,
   value: Uint8Array,
   programId: PublicKey,
-  skipValidation: boolean = false
+  skipConfigIntegrityValidation: boolean = false
 ): TransactionInstruction {
   const args: UpdateReserveConfigArgs = {
-    mode: new BN(mode.discriminator + 1),
+    mode,
     value,
-    skipValidation,
+    skipConfigIntegrityValidation,
   };
 
+  const [globalConfig] = globalConfigPda(programId);
   const accounts: UpdateReserveConfigAccounts = {
-    lendingMarketOwner: signer,
+    signer,
     lendingMarket: marketAddress,
     reserve: reserveAddress,
+    globalConfig,
   };
 
   return updateReserveConfig(args, accounts, programId);
@@ -1265,15 +1267,17 @@ export function updateEntireReserveConfigIx(
   programId: PublicKey
 ): TransactionInstruction {
   const args: UpdateReserveConfigArgs = {
-    mode: new BN(UpdateConfigMode.UpdateEntireReserveConfig.discriminator + 1),
+    mode: new UpdateConfigMode.UpdateEntireReserveConfig(),
     value: encodeUsingLayout(ReserveConfig.layout(), reserveConfig),
-    skipValidation: false,
+    skipConfigIntegrityValidation: false,
   };
 
+  const [globalConfig] = globalConfigPda(programId);
   const accounts: UpdateReserveConfigAccounts = {
-    lendingMarketOwner: signer,
+    signer,
     lendingMarket: marketAddress,
     reserve: reserveAddress,
+    globalConfig,
   };
 
   const ix = updateReserveConfig(args, accounts, programId);

package/src/classes/vault.ts

@@ -1059,13 +1059,14 @@ export class KaminoVaultClient {
   async withdrawIxs(
     user: PublicKey,
     vault: KaminoVault,
-    shareAmount: Decimal,
+    shareAmountToWithdraw: Decimal,
     slot: number,
     vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>,
     farmState?: FarmState
   ): Promise<WithdrawIxs> {
     const vaultState = await vault.getState(this.getConnection());
     const kaminoVault = new KaminoVault(vault.address, vaultState, vault.programId);
+    const hasFarm = await vault.hasFarm(this.getConnection());
 
     const withdrawIxs: WithdrawIxs = {
       unstakeFromFarmIfNeededIxs: [],
@@ -1073,9 +1074,56 @@ export class KaminoVaultClient {
       postWithdrawIxs: [],
     };
 
-    const shareLamportsToWithdraw = collToLamportsDecimal(shareAmount, vaultState.sharesMintDecimals.toNumber());
-    const hasFarm = await vault.hasFarm(this.getConnection());
+    // compute the total shares the user has (in ATA + in farm) and check if they want to withdraw everything or just a part
+    let userSharesAtaBalance = new Decimal(0);
+    const userSharesAta = getAssociatedTokenAddress(vaultState.sharesMint, user);
+    const userSharesAtaState = await this.getConnection().getAccountInfo(userSharesAta);
+    if (userSharesAtaState) {
+      const userSharesAtaBalanceInLamports = getTokenBalanceFromAccountInfoLamports(userSharesAtaState);
+      userSharesAtaBalance = userSharesAtaBalanceInLamports.div(
+        new Decimal(10).pow(vaultState.sharesMintDecimals.toString())
+      );
+    }
+
+    let userSharesInFarm = new Decimal(0);
     if (hasFarm) {
+      userSharesInFarm = await getUserSharesInFarm(
+        this.getConnection(),
+        user,
+        vaultState.vaultFarm,
+        vaultState.sharesMintDecimals.toNumber()
+      );
+    }
+
+    let sharesToWithdraw = shareAmountToWithdraw;
+    const totalUserShares = userSharesAtaBalance.add(userSharesInFarm);
+    let withdrawAllShares = false;
+    if (sharesToWithdraw.gt(totalUserShares)) {
+      sharesToWithdraw = new Decimal(U64_MAX.toString()).div(
+        new Decimal(10).pow(vaultState.sharesMintDecimals.toString())
+      );
+      withdrawAllShares = true;
+    }
+
+    // if not enough shares in ATA unstake from farm
+    const sharesInAtaAreEnoughForWithdraw = sharesToWithdraw.lte(userSharesAtaBalance);
+    if (hasFarm && !sharesInAtaAreEnoughForWithdraw) {
+      // if we need to unstake we need to make sure share ata is created
+      const [{ createAtaIx }] = createAtasIdempotent(user, [
+        {
+          mint: vaultState.sharesMint,
+          tokenProgram: TOKEN_PROGRAM_ID,
+        },
+      ]);
+      withdrawIxs.unstakeFromFarmIfNeededIxs.push(createAtaIx);
+      let shareLamportsToWithdraw = new Decimal(U64_MAX.toString());
+      if (!withdrawAllShares) {
+        const sharesToWithdrawFromFarm = sharesToWithdraw.sub(userSharesAtaBalance);
+        shareLamportsToWithdraw = collToLamportsDecimal(
+          sharesToWithdrawFromFarm,
+          vaultState.sharesMintDecimals.toNumber()
+        );
+      }
       const unstakeAndWithdrawFromFarmIxs = await getFarmUnstakeAndWithdrawIxs(
         this.getConnection(),
         user,
@@ -1096,13 +1144,14 @@ export class KaminoVaultClient {
       const withdrawFromVaultIxs = await this.withdrawWithReserveIxs(
         user,
         kaminoVault,
-        shareAmount,
+        sharesToWithdraw,
+        totalUserShares,
         slot,
         vaultReservesMap
       );
       withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
     } else {
-      const withdrawFromVaultIxs = await this.withdrawFromAvailableIxs(user, kaminoVault, shareAmount);
+      const withdrawFromVaultIxs = await this.withdrawFromAvailableIxs(user, kaminoVault, sharesToWithdraw);
       withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
     }
 
@@ -1113,6 +1162,13 @@ export class KaminoVaultClient {
       withdrawIxs.postWithdrawIxs.push(unwrapIx);
     }
 
+    // if we burn all of user's shares close its shares ATA
+    const burnAllUserShares = sharesToWithdraw.gt(userSharesAtaBalance);
+    if (burnAllUserShares) {
+      const closeAtaIx = createCloseAccountInstruction(userSharesAta, user, user, [], TOKEN_PROGRAM_ID);
+      withdrawIxs.postWithdrawIxs.push(closeAtaIx);
+    }
+
     return withdrawIxs;
   }
 
@@ -1149,6 +1205,7 @@ export class KaminoVaultClient {
     user: PublicKey,
     vault: KaminoVault,
     shareAmount: Decimal,
+    allUserShares: Decimal,
     slot: number,
     vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
   ): Promise<TransactionInstruction[]> {
@@ -1163,7 +1220,12 @@ export class KaminoVaultClient {
       },
     ]);
 
-    const shareLamportsToWithdraw = collToLamportsDecimal(shareAmount, vaultState.sharesMintDecimals.toNumber());
+    const withdrawAllShares = shareAmount.gte(allUserShares);
+    const actualSharesToWithdraw = shareAmount.lte(allUserShares) ? shareAmount : allUserShares;
+    const shareLamportsToWithdraw = collToLamportsDecimal(
+      actualSharesToWithdraw,
+      vaultState.sharesMintDecimals.toNumber()
+    );
     const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot);
     const sharesPerToken = new Decimal(1).div(tokensPerShare);
     const tokensToWithdraw = shareLamportsToWithdraw.mul(tokensPerShare);
@@ -1181,10 +1243,17 @@ export class KaminoVaultClient {
       const firstReserve = vaultState.vaultAllocationStrategy.find(
         (reserve) => !reserve.reserve.equals(PublicKey.default)
       );
-      reserveWithSharesAmountToWithdraw.push({
-        reserve: firstReserve!.reserve,
-        shares: shareLamportsToWithdraw,
-      });
+      if (withdrawAllShares) {
+        reserveWithSharesAmountToWithdraw.push({
+          reserve: firstReserve!.reserve,
+          shares: new Decimal(U64_MAX.toString()),
+        });
+      } else {
+        reserveWithSharesAmountToWithdraw.push({
+          reserve: firstReserve!.reserve,
+          shares: shareLamportsToWithdraw,
+        });
+      }
     } else {
       // Get decreasing order sorted available liquidity to withdraw from each reserve allocated to
       const reserveAllocationAvailableLiquidityToWithdraw = await this.getReserveAllocationAvailableLiquidityToWithdraw(
@@ -1204,9 +1273,13 @@ export class KaminoVaultClient {
             tokensToWithdrawFromReserve = tokensToWithdrawFromReserve.add(availableTokens);
             isFirstWithdraw = false;
           }
-          // round up to the nearest integer the shares to withdraw
-          const sharesToWithdrawFromReserve = tokensToWithdrawFromReserve.mul(sharesPerToken).ceil();
-          reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: sharesToWithdrawFromReserve });
+          if (withdrawAllShares) {
+            reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: new Decimal(U64_MAX.toString()) });
+          } else {
+            // round up to the nearest integer the shares to withdraw
+            const sharesToWithdrawFromReserve = tokensToWithdrawFromReserve.mul(sharesPerToken).ceil();
+            reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: sharesToWithdrawFromReserve });
+          }
 
           tokenLeftToWithdraw = tokenLeftToWithdraw.sub(tokensToWithdrawFromReserve);
         }
@@ -2307,7 +2380,38 @@ export class KaminoVaultClient {
     kaminoMarkets?: KaminoMarket[]
   ): Promise<PubkeyHashMap<PublicKey, MarketOverview>> {
     const vaultReservesStateMap = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
-    const vaultReservesState = Array.from(vaultReservesStateMap.values());
+    const vaultReservesState: KaminoReserve[] = [];
+
+    const missingReserves = new PublicKeySet<PublicKey>([]);
+    // filter the reserves that are not part of the vault allocation strategy
+    vaultState.vaultAllocationStrategy.forEach(async (allocation) => {
+      if (allocation.reserve.equals(PublicKey.default)) {
+        return;
+      }
+      const reserve = vaultReservesStateMap.get(allocation.reserve);
+      if (!reserve) {
+        missingReserves.add(allocation.reserve);
+        return;
+      }
+
+      vaultReservesState.push(reserve);
+    });
+
+    // read missing reserves
+    const missingReservesStates = (await Reserve.fetchMultiple(this.getConnection(), missingReserves.toArray())).filter(
+      (reserve) => reserve !== null
+    );
+    const missingReservesAndOracles = await getTokenOracleData(this.getConnection(), missingReservesStates);
+    missingReservesAndOracles.forEach(([reserve, oracle], index) => {
+      const fetchedReserve = new KaminoReserve(
+        reserve,
+        missingReserves.toArray()[index]!,
+        oracle!,
+        this.getConnection(),
+        this.recentSlotDurationMs
+      );
+      vaultReservesState.push(fetchedReserve);
+    });
 
     const vaultCollateralsPerReserve: PubkeyHashMap<PublicKey, MarketOverview> = new PubkeyHashMap();
 

package/src/classes/vault_types.ts

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

package/src/client_kamino_manager.ts

@@ -8,15 +8,20 @@ import {
   Signer,
   Transaction,
   TransactionInstruction,
+  TransactionMessage,
   TransactionSignature,
   VersionedTransaction,
 } from '@solana/web3.js';
 import {
   AssetReserveConfigCli,
   Chain,
+  createLookupTableIx,
   DEFAULT_RECENT_SLOT_DURATION_MS,
   encodeTokenName,
+  extendLookupTableIxs,
+  getLookupTableAccounts,
   getMedianSlotDurationInMsFromLastEpochs,
+  globalConfigPda,
   initLookupTableIx,
   KaminoManager,
   KaminoMarket,
@@ -27,6 +32,7 @@ import {
   MAINNET_BETA_CHAIN_ID,
   parseZeroPaddedUtf8,
   printHoldings,
+  PROGRAM_ID,
   Reserve,
   ReserveAllocationConfig,
   ReserveWithAddress,
@@ -153,7 +159,10 @@ async function main() {
 
       const _createReserveSig = await processTxn(env.client, env.payer, txnIxs[0], mode, 2500, [reserve]);
 
-      const _updateReserveSig = await processTxn(env.client, env.payer, txnIxs[1], mode, 2500, [], 400_000);
+      const [lut, createLutIxs] = await createUpdateReserveConfigLutIxs(env, marketAddress, reserve.publicKey);
+      await processTxn(env.client, env.payer, createLutIxs, mode, 2500, []);
+
+      const _updateSig = await processTxn(env.client, env.payer, txnIxs[1], mode, 2500, [], 400_000, 1000, [lut]);
 
       mode === 'execute' &&
         console.log(
@@ -1612,7 +1621,8 @@ async function processTxn(
   priorityFeeMultiplier: number = 2500,
   extraSigners: Signer[],
   computeUnits: number = 200_000,
-  priorityFeeLamports: number = 1000
+  priorityFeeLamports: number = 1000,
+  luts: PublicKey[] = []
 ): Promise<TransactionSignature> {
   if (mode !== 'inspect' && mode !== 'simulate' && mode !== 'execute' && mode !== 'multisig') {
     throw new Error('Invalid mode: ' + mode + '. Must be one of: inspect/simulate/execute/multisig');
@@ -1632,25 +1642,27 @@ async function processTxn(
   } else {
     const microLamport = priorityFeeLamports * 10 ** 6; // 1000 lamports
     const microLamportsPrioritizationFee = microLamport / computeUnits;
-
-    const tx = new Transaction();
     const { blockhash } = await web3Client.connection.getLatestBlockhash();
+
     if (priorityFeeMultiplier) {
       const priorityFeeIxn = createAddExtraComputeUnitFeeTransaction(
         computeUnits,
         microLamportsPrioritizationFee * priorityFeeMultiplier
       );
-      tx.add(...priorityFeeIxn);
+      ixs.push(...priorityFeeIxn);
     }
-    tx.recentBlockhash = blockhash;
-    tx.feePayer = admin.publicKey;
-    tx.add(...ixs);
+
+    const tx = new TransactionMessage({
+      payerKey: admin.publicKey,
+      recentBlockhash: blockhash,
+      instructions: ixs,
+    }).compileToV0Message(await getLookupTableAccounts(web3Client.connection, luts));
 
     if (mode === 'execute') {
       return await signSendAndConfirmRawTransactionWithRetry({
         mainConnection: web3Client.sendConnection,
         extraConnections: [],
-        tx: new VersionedTransaction(tx.compileMessage()),
+        tx: new VersionedTransaction(tx),
         signers: [admin, ...extraSigners],
         commitment: 'confirmed',
         sendTransactionOptions: {
@@ -1659,9 +1671,7 @@ async function processTxn(
         },
       });
     } else if (mode === 'simulate') {
-      const simulation = await web3Client.sendConnection.simulateTransaction(
-        new VersionedTransaction(tx.compileMessage())
-      );
+      const simulation = await web3Client.sendConnection.simulateTransaction(new VersionedTransaction(tx));
       if (simulation.value.logs && simulation.value.logs.length > 0) {
         console.log('Simulation: \n' + simulation.value.logs);
       } else {
@@ -1671,7 +1681,7 @@ async function processTxn(
       console.log(
         'Tx in B64',
         `https://explorer.solana.com/tx/inspector?message=${encodeURIComponent(
-          tx.serializeMessage().toString('base64')
+          Buffer.from(tx.serialize()).toString('base64')
         )}`
       );
     }
@@ -1869,3 +1879,15 @@ function parseReserveConfigToFile(reserveConfig: ReserveConfig) {
     reserved2: Array(9).fill(0),
   };
 }
+
+async function createUpdateReserveConfigLutIxs(
+  env: Env,
+  lendingMarketAddress: PublicKey,
+  reserveAddress: PublicKey
+): Promise<[PublicKey, TransactionInstruction[]]> {
+  const [globalConfigAddress] = globalConfigPda(PROGRAM_ID);
+  const contents = [globalConfigAddress, lendingMarketAddress, reserveAddress];
+  const [createIx, lut] = await createLookupTableIx(env.connection, env.payer.publicKey);
+  const extendIxs = extendLookupTableIxs(env.payer.publicKey, lut, contents);
+  return [lut, [createIx, ...extendIxs]];
+}