@kamino-finance/klend-sdk 7.1.10 → 7.2.1

package/src/manager/client_kamino_manager.ts

@@ -20,7 +20,6 @@ import {
   lamportsToDecimal,
   LendingMarket,
   parseZeroPaddedUtf8,
-  printHoldings,
   Reserve,
   ReserveAllocationConfig,
   ReserveWithAddress,
@@ -49,6 +48,7 @@ import { initEnv, ManagerEnv } from './tx/ManagerEnv';
 import { processTx } from './tx/processor';
 import { getPriorityFeeAndCuIxs } from '../client/tx/priorityFee';
 import { fetchAddressLookupTable, fetchAllAddressLookupTable } from '@solana-program/address-lookup-table';
+import { noopSigner } from '../utils/signer';
 
 dotenv.config({
   path: `.env${process.env.ENV ? '.' + process.env.ENV : ''}`,
@@ -401,7 +401,7 @@ async function main() {
     .option(`--staging`, 'If true, will use the staging programs')
     .action(async ({ vault, mode, symbol, extraName, staging }) => {
       const env = await initEnv(undefined, staging);
-      const kVault = new KaminoVault(address(vault));
+      const kVault = new KaminoVault(env.c.rpc, address(vault));
 
       const kaminoManager = new KaminoManager(
         env.c.rpc,
@@ -409,7 +409,7 @@ async function main() {
         env.klendProgramId,
         env.kvaultProgramId
       );
-      const vaultState = await kVault.getState(env.c.rpc);
+      const vaultState = await kVault.getState();
       const signer = await env.getSigner({ vaultState });
       const ix = await kaminoManager.getSetSharesMetadataIx(signer, kVault, symbol, extraName);
 
@@ -447,8 +447,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const signer = await env.getSigner({ vaultState });
 
       const instructions = await kaminoManager.updateVaultConfigIxs(
@@ -496,8 +496,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const signer = await env.getSigner({ vaultState });
 
       const instructions = await kaminoManager.updateVaultConfigIxs(kaminoVault, field, value, signer);
@@ -539,8 +539,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const signer = await env.getSigner({ vaultState });
       const instructions = await kaminoManager.updateVaultConfigIxs(
         kaminoVault,
@@ -651,8 +651,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const signer = await env.getSigner({ vaultState });
       const syncLUTIxs = await kaminoManager.syncVaultLUTIxs(signer, kaminoVault);
 
@@ -711,8 +711,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const signer = await env.getSigner({ vaultState });
       const instructions = await kaminoManager.updateVaultConfigIxs(
         kaminoVault,
@@ -757,8 +757,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const pendingAdmin = await env.getSigner({
         vaultState,
         useVaultPendingAdmin: true,
@@ -835,8 +835,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const signer = await env.getSigner({ vaultState });
       const instruction = await kaminoManager.giveUpPendingFeesIx(kaminoVault, new Decimal(maxAmountToGiveUp), signer);
 
@@ -875,8 +875,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const signer = await env.getSigner({ vaultState });
 
       const instructions = await kaminoManager.withdrawPendingFeesIxs(
@@ -922,8 +922,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const signer = await env.getSigner({ vaultState });
 
       const ixs = await kaminoManager.fullRemoveReserveFromVaultIxs(signer, kaminoVault, reserveAddress);
@@ -964,7 +964,7 @@ async function main() {
       const user = await env.getSigner();
       const vaultAddress = address(vault);
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
 
       const stakeIxs = await new KaminoManager(
         env.c.rpc,
@@ -992,15 +992,16 @@ async function main() {
     .command('update-vault-reserve-allocation')
     .requiredOption('--vault <string>', 'Vault address')
     .requiredOption('--reserve <string>', 'Reserve address')
-    .requiredOption('--allocation-weight <number>', 'Allocation weight')
-    .requiredOption('--allocation-cap <string>', 'Allocation cap decimal value')
     .requiredOption(
       `--mode <string>`,
       'simulate|multisig|execute - simulate - to print txn simulation and to get tx simulation link in explorer, execute - execute tx, multisig - to get bs58 tx for multisig usage'
     )
+    .option('--allocation-weight <number>', 'Allocation weight')
+    .option('--allocation-cap <string>', 'Allocation cap decimal value')
     .option(`--staging`, 'If true, will use the staging programs')
     .option(`--multisig <string>`, 'If using multisig mode this is required, otherwise will be ignored')
-    .action(async ({ vault, reserve, allocationWeight, allocationCap, mode, staging, multisig }) => {
+    .option(`--skip-lut-update`, 'If set, it will skip the LUT update')
+    .action(async ({ vault, reserve, mode, allocationWeight, allocationCap, staging, multisig, skipLutUpdate }) => {
       if (mode === 'multisig' && !multisig) {
         throw new Error('If using multisig mode, multisig is required');
       }
@@ -1008,11 +1009,12 @@ async function main() {
       const env = await initEnv(staging, ms);
       const reserveAddress = address(reserve);
       const vaultAddress = address(vault);
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const signer = await env.getSigner({ vaultState });
-      const allocationWeightValue = Number(allocationWeight);
-      const allocationCapDecimal = new Decimal(allocationCap);
+      const shouldUpdateLut = skipLutUpdate ? false : true;
+      let allocationWeightValue: number;
+      let allocationCapDecimal: Decimal;
 
       const kaminoManager = new KaminoManager(
         env.c.rpc,
@@ -1025,6 +1027,29 @@ async function main() {
         throw new Error('Reserve not found');
       }
 
+      const existentAllocation = kaminoManager.getVaultAllocations(vaultState).get(reserveAddress);
+
+      if (allocationWeight) {
+        allocationWeightValue = Number(allocationWeight);
+      } else if (existentAllocation) {
+        allocationWeightValue = existentAllocation.targetWeight.toNumber();
+      } else {
+        throw new Error('Allocation weight is required');
+      }
+
+      if (allocationCap) {
+        allocationCapDecimal = new Decimal(allocationCap);
+      } else if (existentAllocation) {
+        allocationCapDecimal = existentAllocation.tokenAllocationCap.div(
+          new Decimal(10).pow(Number(vaultState.tokenMintDecimals.toString()))
+        );
+      } else {
+        throw new Error('Allocation cap is required');
+      }
+
+      console.log('allocationWeightValue', allocationWeightValue);
+      console.log('allocationCapDecimal', allocationCapDecimal.toString());
+
       const reserveWithAddress: ReserveWithAddress = {
         address: reserveAddress,
         state: reserveState,
@@ -1040,19 +1065,17 @@ async function main() {
         firstReserveAllocationConfig,
         signer
       );
-      await processTx(
-        env.c,
-        signer,
-        [
-          instructions.updateReserveAllocationIx,
-          ...instructions.updateLUTIxs,
-          ...getPriorityFeeAndCuIxs({
-            priorityFeeMultiplier: 2500,
-          }),
-        ],
-        mode,
-        []
-      );
+      const txInstructions = [
+        instructions.updateReserveAllocationIx,
+        ...instructions.updateLUTIxs,
+        ...getPriorityFeeAndCuIxs({
+          priorityFeeMultiplier: 2500,
+        }),
+      ];
+      if (shouldUpdateLut) {
+        txInstructions.push(...instructions.updateLUTIxs);
+      }
+      await processTx(env.c, signer, txInstructions, mode, []);
 
       mode === 'execute' && console.log('Vault allocation updated');
     });
@@ -1081,7 +1104,7 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
       const payer = await env.getSigner();
       const depositInstructions = await kaminoManager.depositToVaultIxs(payer, kaminoVault, amount);
       const instructions = [...depositInstructions.depositIxs, ...depositInstructions.stakeInFarmIfNeededIxs];
@@ -1128,8 +1151,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      const vaultState = await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+      const vaultState = await kaminoVault.getState();
       const lookupTableAddresses = [];
       if (vaultState.vaultLookupTable !== DEFAULT_PUBLIC_KEY) {
         lookupTableAddresses.push(vaultState.vaultLookupTable);
@@ -1186,7 +1209,7 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
       const instructions = await kaminoManager.investAllReservesIxs(payer, kaminoVault);
 
       for (let i = 0; i < instructions.length; i++) {
@@ -1234,7 +1257,8 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
+
       const reserveAddress = address(reserve);
       const reserveState = await Reserve.fetch(env.c.rpc, reserveAddress, env.klendProgramId);
       if (!reserveState) {
@@ -1292,7 +1316,7 @@ async function main() {
       const kaminoManager = new KaminoManager(env.c.rpc, slotDuration, env.klendProgramId, env.kvaultProgramId);
 
       const vaultAddress = address(vault);
-      const vaultState = await new KaminoVault(vaultAddress, undefined, env.kvaultProgramId).getState(env.c.rpc);
+      const vaultState = await new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId).getState();
       const vaultCollaterals = await kaminoManager.getVaultCollaterals(
         vaultState,
         await env.c.rpc.getSlot({ commitment: 'confirmed' }).send()
@@ -1317,9 +1341,9 @@ async function main() {
       const kaminoManager = new KaminoManager(env.c.rpc, slotDuration, env.klendProgramId, env.kvaultProgramId);
 
       const vaultAddress = address(vault);
-      const vaultState = await new KaminoVault(vaultAddress, undefined, env.kvaultProgramId).getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId);
       const vaultOverview = await kaminoManager.getVaultOverview(
-        vaultState,
+        kaminoVault,
         new Decimal(tokenPrice),
         await env.c.rpc.getSlot({ commitment: 'confirmed' }).send()
       );
@@ -1342,7 +1366,7 @@ async function main() {
 
       const kaminoManager = new KaminoManager(env.c.rpc, slotDuration, env.klendProgramId, env.kvaultProgramId);
 
-      const kaminoVault = new KaminoVault(address(vault));
+      const kaminoVault = new KaminoVault(env.c.rpc, address(vault), undefined, env.kvaultProgramId, slotDuration);
       const farmAPY = await kaminoManager.getVaultFarmRewardsAPY(kaminoVault, new Decimal(tokenPrice));
       console.log('farmAPY', farmAPY);
     });
@@ -1373,7 +1397,7 @@ async function main() {
       const kaminoManager = new KaminoManager(env.c.rpc, slotDuration, env.klendProgramId, env.kvaultProgramId);
 
       const vaultAddress = address(vault);
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId, slotDuration);
 
       const allVaultsTokenMints = await kaminoManager.getAllVaultsTokenMintsIncludingRewards([kaminoVault]);
       console.log('allVaultsTokenMints', allVaultsTokenMints);
@@ -1390,7 +1414,13 @@ async function main() {
       const kaminoManager = new KaminoManager(env.c.rpc, slotDuration, env.klendProgramId, env.kvaultProgramId);
 
       const vaultAddress = address(vault);
-      const vaultState = await new KaminoVault(vaultAddress, undefined, env.kvaultProgramId).getState(env.c.rpc);
+      const vaultState = await new KaminoVault(
+        env.c.rpc,
+        vaultAddress,
+        undefined,
+        env.kvaultProgramId,
+        slotDuration
+      ).getState();
       const allocationDistribution = kaminoManager.getAllocationsDistribuionPct(vaultState);
 
       allocationDistribution.forEach((allocation, reserveAddress) => {
@@ -1412,7 +1442,7 @@ async function main() {
 
       const vaultAddress = address(vault);
       const walletAddress = address(wallet);
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId, slotDuration);
       const userShares = await kaminoManager.getUserSharesBalanceSingleVault(walletAddress, kaminoVault);
       console.log(
         `User shares for vault ${vaultAddress}: unstaked shares: ${userShares.unstakedShares} staked shares: ${userShares.stakedShares} total shares: ${userShares.totalShares}`
@@ -1451,7 +1481,7 @@ async function main() {
       const kaminoManager = new KaminoManager(env.c.rpc, slotDuration, env.klendProgramId, env.kvaultProgramId);
 
       const vaultAddress = address(vault);
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId, slotDuration);
       const tokensPerShare = await kaminoManager.getTokensPerShareSingleVault(
         kaminoVault,
         await env.c.rpc.getSlot({ commitment: 'confirmed' }).send()
@@ -1470,26 +1500,25 @@ async function main() {
       const kaminoManager = new KaminoManager(env.c.rpc, slotDuration, env.klendProgramId, env.kvaultProgramId);
 
       const vaultAddress = address(vault);
-      const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kvaultProgramId);
-      await kaminoVault.getState(env.c.rpc);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress, undefined, env.kvaultProgramId, slotDuration);
+      const vaultState = await kaminoVault.getState();
 
       const slot = await env.c.rpc.getSlot({ commitment: 'confirmed' }).send();
       const tokensPerShare = await kaminoManager.getTokensPerShareSingleVault(kaminoVault, slot);
       const holdings = await kaminoManager.getVaultHoldings(kaminoVault.state!, slot);
-      const vaultState = kaminoVault.state!;
 
       const sharesIssued = lamportsToDecimal(
         vaultState.sharesIssued.toString(),
         vaultState.sharesMintDecimals.toString()
       );
 
-      const vaultOverview = await kaminoManager.getVaultOverview(vaultState, new Decimal(1.0), slot);
+      const vaultOverview = await kaminoManager.getVaultOverview(kaminoVault, new Decimal(1.0), slot);
 
       console.log('farm', vaultState.vaultFarm.toString());
       console.log('vault token mint', vaultState.tokenMint);
       console.log('Name: ', kaminoManager.getDecodedVaultName(kaminoVault.state!));
       console.log('Shares issued: ', sharesIssued);
-      printHoldings(holdings);
+      holdings.print();
       console.log(`Tokens per share for vault ${vaultAddress}: ${tokensPerShare}`);
       console.log('vaultOverview', vaultOverview);
 
@@ -1613,7 +1642,13 @@ async function main() {
       const slotDuration = await getMedianSlotDurationInMsFromLastEpochs();
 
       const kaminoManager = new KaminoManager(env.c.rpc, slotDuration, env.klendProgramId, env.kvaultProgramId);
-      const vaultState = await new KaminoVault(vaultAddress, undefined, env.kvaultProgramId).getState(env.c.rpc);
+      const vaultState = await new KaminoVault(
+        env.c.rpc,
+        vaultAddress,
+        undefined,
+        env.kvaultProgramId,
+        slotDuration
+      ).getState();
 
       const simulatedHoldings = await kaminoManager.calculateSimulatedHoldingsWithInterest(vaultState);
 
@@ -1657,7 +1692,13 @@ async function main() {
       const slotDuration = await getMedianSlotDurationInMsFromLastEpochs();
 
       const kaminoManager = new KaminoManager(env.c.rpc, slotDuration, env.klendProgramId, env.kvaultProgramId);
-      const vaultState = await new KaminoVault(vaultAddress, undefined, env.kvaultProgramId).getState(env.c.rpc);
+      const vaultState = await new KaminoVault(
+        env.c.rpc,
+        vaultAddress,
+        undefined,
+        env.kvaultProgramId,
+        slotDuration
+      ).getState();
 
       const computedAllocation = await kaminoManager.getVaultComputedReservesAllocation(vaultState);
       console.log('computedAllocation', computedAllocation);
@@ -1975,6 +2016,47 @@ async function main() {
       console.log(adminInfo);
     });
 
+  commands
+    .command('claim-rewards-for-vault')
+    .requiredOption('--vault <string>', 'Vault address')
+    .requiredOption(
+      `--mode <string>`,
+      'simulate|multisig|execute - simulate - to print txn simulation and to get tx simulation link in explorer, execute - execute tx, multisig - to get bs58 tx for multisig usage'
+    )
+    .option(`--staging`, 'If true, will use the staging programs')
+    .option(`--user <string>`, 'User address')
+    .action(async ({ vault, mode, staging, user }) => {
+      const env = await initEnv(staging);
+      const vaultAddress = address(vault);
+      const kaminoVault = new KaminoVault(env.c.rpc, vaultAddress);
+      const kaminoManager = new KaminoManager(
+        env.c.rpc,
+        DEFAULT_RECENT_SLOT_DURATION_MS,
+        env.klendProgramId,
+        env.kvaultProgramId
+      );
+      const userWallet = user ? noopSigner(address(user)) : await env.getSigner();
+      const rewardsIxs = await kaminoManager.getClaimAllRewardsForVaultIxs(userWallet, kaminoVault);
+
+      if (rewardsIxs.length > 0) {
+        await processTx(
+          env.c,
+          userWallet,
+          [
+            ...rewardsIxs,
+            ...getPriorityFeeAndCuIxs({
+              priorityFeeMultiplier: 2500,
+              computeUnits: 400_000,
+            }),
+          ],
+          mode,
+          []
+        );
+      } else {
+        console.log('No rewards to claim');
+      }
+    });
+
   await commands.parseAsync();
 }
 

package/src/utils/farmUtils.ts

@@ -20,7 +20,6 @@ export async function getReserveFarmRewardsAPY(
   farmsClient: Farms,
   slot: Slot,
   reserveState?: Reserve,
-  cTokenMintDecimals?: number,
   tokensPrices?: Map<Address, Decimal>
 ): Promise<ReserveIncentives> {
   const reserveIncentives: ReserveIncentives = {