@kamino-finance/klend-sdk 5.4.1 → 5.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kamino-finance/klend-sdk",
-  "version": "5.4.1",
+  "version": "5.4.3",
   "description": "Typescript SDK for interacting with the Kamino Lending (klend) protocol",
   "repository": {
     "type": "git",

package/src/classes/action.ts

@@ -2023,7 +2023,7 @@ export class KaminoAction {
     const borrowReservesReferrerTokenStates = borrowReservesList
       .map((reserve) => {
         if (this.referrer.equals(PublicKey.default)) {
-          return { pubkey: this.kaminoMarket.programId, isSigner: false, isWritable: true };
+          return { pubkey: this.kaminoMarket.programId, isSigner: false, isWritable: false };
         }
         const referrerTokenStateAddress = referrerTokenStatePda(this.referrer, reserve, this.kaminoMarket.programId)[0];
         return { pubkey: referrerTokenStateAddress, isSigner: false, isWritable: true };
@@ -2081,7 +2081,7 @@ export class KaminoAction {
     const borrowReservesReferrerTokenStates = borrowReservesList
       .map((reserve) => {
         if (this.referrer.equals(PublicKey.default)) {
-          return { pubkey: this.kaminoMarket.programId, isSigner: false, isWritable: true };
+          return { pubkey: this.kaminoMarket.programId, isSigner: false, isWritable: false };
         }
         const reserveState = this.kaminoMarket.getReserveByAddress(reserve)!;
         const referrerTokenStateAddress = referrerTokenStatePda(

package/src/classes/vault.ts

@@ -676,8 +676,8 @@ export class KaminoVaultClient {
     const kaminoVault = new KaminoVault(vault.address, vaultState, vault.programId);
 
     // if the vault has allocations withdraw otherwise wtihdraw from available ix
-    const vaultAllocation = vaultState.vaultAllocationStrategy.find(
-      (allocation) => ~allocation.reserve.equals(PublicKey.default)
+    const vaultAllocation = vaultState.vaultAllocationStrategy.find((allocation) =>
+      allocation.reserve.equals(PublicKey.default)
     );
 
     if (vaultAllocation) {
@@ -735,18 +735,25 @@ export class KaminoVaultClient {
       },
     ]);
 
-    const tokensToWithdraw = shareAmount.mul(await this.getTokensPerShareSingleVault(vault, slot));
+    const shareLamportsToWithdraw = collToLamportsDecimal(shareAmount, vaultState.sharesMintDecimals.toNumber());
+    const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot);
+    const sharesPerToken = new Decimal(1).div(tokensPerShare);
+    const tokensToWithdraw = shareLamportsToWithdraw.mul(tokensPerShare);
     let tokenLeftToWithdraw = tokensToWithdraw;
+    const availableTokens = new Decimal(vaultState.tokenAvailable.toString());
+    tokenLeftToWithdraw = tokenLeftToWithdraw.sub(availableTokens);
 
-    tokenLeftToWithdraw = tokenLeftToWithdraw.sub(new Decimal(vaultState.tokenAvailable.toString()));
+    type ReserveWithTokensToWithdraw = { reserve: PublicKey; shares: Decimal };
 
-    const reservesToWithdraw: PublicKey[] = [];
-    const amountToWithdraw: Decimal[] = [];
-    amountToWithdraw.push(new Decimal(vaultState.tokenAvailable.toString()));
+    const reserveWithSharesAmountToWithdraw: ReserveWithTokensToWithdraw[] = [];
+    let isFirstWithdraw = true;
 
     if (tokenLeftToWithdraw.lte(0)) {
       // Availabe enough to withdraw all - using first reserve as it does not matter
-      reservesToWithdraw.push(vaultState.vaultAllocationStrategy[0].reserve);
+      reserveWithSharesAmountToWithdraw.push({
+        reserve: vaultState.vaultAllocationStrategy[0].reserve,
+        shares: shareLamportsToWithdraw,
+      });
     } else {
       // Get decreasing order sorted available liquidity to withdraw from each reserve allocated to
       const reserveAllocationAvailableLiquidityToWithdraw = await this.getReserveAllocationAvailableLiquidityToWithdraw(
@@ -755,15 +762,22 @@ export class KaminoVaultClient {
         vaultReservesState
       );
       // sort
-      const reserveAllocationAvailableLiquidityToWithdrawSorted = new PubkeyHashMap(
-        [...reserveAllocationAvailableLiquidityToWithdraw.entries()].sort((a, b) => b[1].sub(a[1]).toNumber())
-      );
+      const reserveAllocationAvailableLiquidityToWithdrawSorted = [
+        ...reserveAllocationAvailableLiquidityToWithdraw.entries(),
+      ].sort((a, b) => b[1].sub(a[1]).toNumber());
 
-      reserveAllocationAvailableLiquidityToWithdrawSorted.forEach((availableLiquidityToWithdraw, key) => {
+      reserveAllocationAvailableLiquidityToWithdrawSorted.forEach(([key, availableLiquidityToWithdraw], _) => {
         if (tokenLeftToWithdraw.gt(0)) {
-          reservesToWithdraw.push(key);
-          tokenLeftToWithdraw = tokenLeftToWithdraw.sub(availableLiquidityToWithdraw);
-          amountToWithdraw.push(Decimal.min(tokenLeftToWithdraw, availableLiquidityToWithdraw));
+          let tokensToWithdrawFromReserve = Decimal.min(tokenLeftToWithdraw, availableLiquidityToWithdraw);
+          if (isFirstWithdraw) {
+            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 });
+
+          tokenLeftToWithdraw = tokenLeftToWithdraw.sub(tokensToWithdrawFromReserve);
         }
       });
     }
@@ -771,26 +785,35 @@ export class KaminoVaultClient {
     const withdrawIxns: TransactionInstruction[] = [];
     withdrawIxns.push(createAtaIx);
 
-    reservesToWithdraw.forEach((reserve, index) => {
-      const reserveState = vaultReservesState.get(reserve);
+    // let sharesLeftToWithdraw = shareAmount;
+    for (let reserveIndex = 0; reserveIndex < reserveWithSharesAmountToWithdraw.length; reserveIndex++) {
+      const reserveWithTokens = reserveWithSharesAmountToWithdraw[reserveIndex];
+      const reserveState = vaultReservesState.get(reserveWithTokens.reserve);
       if (reserveState === undefined) {
-        throw new Error(`Reserve ${reserve.toBase58()} not found in vault reserves map`);
+        throw new Error(`Reserve ${reserveWithTokens.reserve.toBase58()} not found in vault reserves map`);
       }
-
       const marketAddress = reserveState.state.lendingMarket;
+
+      const isLastWithdraw = reserveIndex === reserveWithSharesAmountToWithdraw.length - 1;
+      // if it is not last withdraw it means that we can pass all shares as we are withdrawing everything from that reserve
+      let sharesToWithdraw = shareAmount;
+      if (isLastWithdraw) {
+        sharesToWithdraw = reserveWithTokens.shares;
+      }
+      
       const withdrawFromReserveIx = this.withdrawIxn(
         user,
         vault,
         vaultState,
         marketAddress,
-        { address: reserve, state: reserveState.state },
+        { address: reserveWithTokens.reserve, state: reserveState.state },
         userSharesAta,
         userTokenAta,
-        amountToWithdraw[index],
+        sharesToWithdraw,
         vaultReservesState
       );
       withdrawIxns.push(withdrawFromReserveIx);
-    });
+    }
 
     return withdrawIxns;
   }
@@ -1484,18 +1507,23 @@ export class KaminoVaultClient {
 
     const reserveAllocationAvailableLiquidityToWithdraw = new PubkeyHashMap<PublicKey, Decimal>();
     vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
+      if (allocationStrategy.reserve.equals(PublicKey.default)) {
+        return;
+      }
       const reserve = reserves.get(allocationStrategy.reserve);
       if (reserve === undefined) {
         throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
       }
-      const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(
-        slot,
-        new Fraction(reserve.state.liquidity.absoluteReferralRateSf)
+      let referralFeeBps = 0;
+      const denominator = reserve.state.config.protocolTakeRatePct / 100;
+      if (denominator > 0) {
+        referralFeeBps = new Fraction(reserve.state.liquidity.absoluteReferralRateSf)
           .toDecimal()
-          .div(reserve.state.config.protocolTakeRatePct / 100)
+          .div(denominator)
           .floor()
-          .toNumber()
-      );
+          .toNumber();
+      }
+      const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, referralFeeBps);
       const reserveAllocationLiquidityAmount = new Decimal(allocationStrategy.ctokenAllocation.toString()).div(
         reserveCollExchangeRate
       );

package/src/client_kamino_manager.ts

@@ -649,7 +649,7 @@ async function main() {
       const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
       const instructions = await kaminoManager.depositToVaultIxs(env.payer.publicKey, kaminoVault, amount);
 
-      const depositSig = await processTxn(env.client, env.payer, instructions, mode, 2500, []);
+      const depositSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 800_000);
 
       mode === 'execute' && console.log('User deposit:', depositSig);
     });
@@ -675,14 +675,14 @@ async function main() {
       const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
       const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
-      const instructions = await kaminoManager.withdrawFromVaultIxs(
+      const withdrawIxs = await kaminoManager.withdrawFromVaultIxs(
         env.payer.publicKey,
         kaminoVault,
         new Decimal(amount),
         await env.connection.getSlot('confirmed')
       );
 
-      const depositSig = await processTxn(env.client, env.payer, instructions, mode, 2500, []);
+      const depositSig = await processTxn(env.client, env.payer, withdrawIxs, mode, 2500, [], 800_000);
 
       mode === 'execute' && console.log('User withdraw:', depositSig);
     });
@@ -754,7 +754,7 @@ async function main() {
         kaminoVault,
         reserveWithAddress
       );
-      const investReserveSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 800_000);
+      const investReserveSig = await processTxn(env.client, env.payer, instructions, mode, 2500, [], 400_000);
 
       mode === 'execute' && console.log('Reserve invested:', investReserveSig);
     });
@@ -926,6 +926,17 @@ async function main() {
     console.log('all vaults', allVaults);
   });
 
+  commands.command('get-all-vaults-pks').action(async () => {
+    const env = initializeClient(false, false);
+    const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+    const allVaults = await kaminoManager.getAllVaults();
+    console.log(
+      'all vaults',
+      allVaults.map((vault) => vault.address.toBase58())
+    );
+  });
+
   commands
     .command('get-simulated-interest-and-fees')
     .requiredOption('--vault <string>', 'Vault address')

package/src/idl_codegen_kamino_vault/accounts/VaultState.ts

@@ -231,7 +231,7 @@ export class VaultState {
   }
 
   static decode(data: Buffer): VaultState {
-    if (!data.slice(0, 8).equals(VaultState.discriminator)) {
+    if (!VaultState.discriminator.equals(data.slice(0, 8))) {
       throw new Error("invalid account discriminator")
     }