@kamino-finance/klend-sdk 7.2.1 → 7.2.3

package/src/classes/vault.ts

@@ -697,13 +697,17 @@ export class KaminoVaultClient {
    * @param mode the field to update (based on VaultConfigFieldKind enum)
    * @param value the value to update the field with
    * @param [vaultAdminAuthority] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx
+   * @param [lutIxsSigner] the signer of the transaction to be used for the lookup table instructions. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx
+   * @param [skipLutUpdate] if true, the lookup table instructions will not be included in the returned instructions
    * @returns a struct that contains the instruction to update the field and an optional list of instructions to update the lookup table
    */
   async updateVaultConfigIxs(
     vault: KaminoVault,
     mode: VaultConfigFieldKind,
     value: string,
-    vaultAdminAuthority?: TransactionSigner
+    vaultAdminAuthority?: TransactionSigner,
+    lutIxsSigner?: TransactionSigner,
+    skipLutUpdate: boolean = false
   ): Promise<UpdateVaultConfigIxs> {
     const vaultState: VaultState = await vault.getState();
     const admin = parseVaultAdmin(vaultState, vaultAdminAuthority);
@@ -753,36 +757,41 @@ export class KaminoVaultClient {
 
     const updateLUTIxs: Instruction[] = [];
 
-    if (mode.kind === new VaultConfigField.PendingVaultAdmin().kind) {
-      const newPubkey = address(value);
-      const insertIntoLutIxs = await insertIntoLookupTableIxs(
-        this.getConnection(),
-        admin,
-        vaultState.vaultLookupTable,
-        [newPubkey]
-      );
-      updateLUTIxs.push(...insertIntoLutIxs);
-    } else if (mode.kind === new VaultConfigField.Farm().kind) {
-      const keysToAddToLUT = [address(value)];
-      // if the farm already exist we want to read its state to add it to the LUT
-      try {
-        const farmState = await FarmState.fetch(this.getConnection(), keysToAddToLUT[0]);
-        keysToAddToLUT.push(
-          farmState!.farmVault,
-          farmState!.farmVaultsAuthority,
-          farmState!.token.mint,
-          farmState!.scopePrices,
-          farmState!.globalConfig
-        );
+    if (!skipLutUpdate) {
+      const lutIxsSignerAccount = lutIxsSigner ? lutIxsSigner : admin;
+
+      if (mode.kind === new VaultConfigField.PendingVaultAdmin().kind) {
+        const newPubkey = address(value);
+
         const insertIntoLutIxs = await insertIntoLookupTableIxs(
           this.getConnection(),
-          admin,
+          lutIxsSignerAccount,
           vaultState.vaultLookupTable,
-          keysToAddToLUT
+          [newPubkey]
         );
         updateLUTIxs.push(...insertIntoLutIxs);
-      } catch (error) {
-        console.log(`Error fetching farm ${keysToAddToLUT[0].toString()} state`, error);
+      } else if (mode.kind === new VaultConfigField.Farm().kind) {
+        const keysToAddToLUT = [address(value)];
+        // if the farm already exist we want to read its state to add it to the LUT
+        try {
+          const farmState = await FarmState.fetch(this.getConnection(), keysToAddToLUT[0]);
+          keysToAddToLUT.push(
+            farmState!.farmVault,
+            farmState!.farmVaultsAuthority,
+            farmState!.token.mint,
+            farmState!.scopePrices,
+            farmState!.globalConfig
+          );
+          const insertIntoLutIxs = await insertIntoLookupTableIxs(
+            this.getConnection(),
+            lutIxsSignerAccount,
+            vaultState.vaultLookupTable,
+            keysToAddToLUT
+          );
+          updateLUTIxs.push(...insertIntoLutIxs);
+        } catch (error) {
+          console.log(`Error fetching farm ${keysToAddToLUT[0].toString()} state`, error);
+        }
       }
     }
 
@@ -799,19 +808,30 @@ export class KaminoVaultClient {
    * @param farm - the farm where the vault shares can be staked
    * @param [errorOnOverride] - if true, the function will throw an error if the vault already has a farm. If false, it will override the farm
    * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
-   *
+   * @param [lutIxsSigner] - the signer of the transaction to be used for the lookup table instructions. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx
+   * @param [skipLutUpdate] - if true, the lookup table instructions will not be included in the returned instructions
+   * @returns - a struct that contains the instruction to update the farm and an optional list of instructions to update the lookup table
    */
   async setVaultFarmIxs(
     vault: KaminoVault,
     farm: Address,
     errorOnOverride: boolean = true,
-    vaultAdminAuthority?: TransactionSigner
+    vaultAdminAuthority?: TransactionSigner,
+    lutIxsSigner?: TransactionSigner,
+    skipLutUpdate: boolean = false
   ): Promise<UpdateVaultConfigIxs> {
     const vaultHasFarm = await vault.hasFarm();
     if (vaultHasFarm && errorOnOverride) {
       throw new Error('Vault already has a farm, if you want to override it set errorOnOverride to false');
     }
-    return this.updateVaultConfigIxs(vault, new VaultConfigField.Farm(), farm, vaultAdminAuthority);
+    return this.updateVaultConfigIxs(
+      vault,
+      new VaultConfigField.Farm(),
+      farm,
+      vaultAdminAuthority,
+      lutIxsSigner,
+      skipLutUpdate
+    );
   }
 
   /**
@@ -2848,6 +2868,55 @@ export class KaminoVaultClient {
     };
   }
 
+  /**
+   * This will return a map of the cumulative rewards issued for all the delegated farms
+   * @param [vaults] - the vaults to get the cumulative rewards for; if not provided, the function will get the cumulative rewards for all the vaults
+   * @returns a map of the cumulative rewards issued for all the delegated farms, per token, in lamports
+   */
+  async getCumulativeDelegatedFarmsRewardsIssuedForAllVaults(vaults?: Address[]): Promise<Map<Address, Decimal>> {
+    const vaultsWithDelegatedFarms = await this.getVaultsWithDelegatedFarm();
+    const delegatedFarmsAddresses: Address[] = [];
+    if (vaults) {
+      vaults.forEach((vault) => {
+        const delegatedFarm = vaultsWithDelegatedFarms.get(vault);
+        if (delegatedFarm) {
+          delegatedFarmsAddresses.push(delegatedFarm);
+        }
+      });
+    } else {
+      delegatedFarmsAddresses.push(...Array.from(vaultsWithDelegatedFarms.values()));
+    }
+
+    const farmsSDK = new Farms(this.getConnection());
+    const delegatedFarmsStates = await farmsSDK.fetchMultipleFarmStatesWithCheckedSize(delegatedFarmsAddresses);
+
+    const cumulativeRewardsPerToken = new Map<Address, Decimal>();
+    for (const delegatedFarmState of delegatedFarmsStates) {
+      if (!delegatedFarmState) {
+        continue;
+      }
+
+      delegatedFarmState.rewardInfos.forEach((rewardInfo) => {
+        if (rewardInfo.token.mint === DEFAULT_PUBLIC_KEY) {
+          return;
+        }
+        const rewardTokenMint = rewardInfo.token.mint;
+        if (cumulativeRewardsPerToken.has(rewardTokenMint)) {
+          cumulativeRewardsPerToken.set(
+            rewardTokenMint,
+            cumulativeRewardsPerToken
+              .get(rewardTokenMint)!
+              .add(new Decimal(rewardInfo.rewardsIssuedCumulative.toString()))
+          );
+        } else {
+          cumulativeRewardsPerToken.set(rewardTokenMint, new Decimal(rewardInfo.rewardsIssuedCumulative.toString()));
+        }
+      });
+    }
+
+    return cumulativeRewardsPerToken;
+  }
+
   /**
    * This will return an overview of each reserve that is part of the vault allocation
    * @param vault - the kamino vault to get available liquidity to withdraw for
@@ -3438,6 +3507,36 @@ export class KaminoVaultClient {
     return address(delegatedFarmWithVault.farm);
   }
 
+  /**
+   * gets all the delegated farms addresses
+   * @returns a list of delegated farms addresses
+   */
+  async getAllDelegatedFarms(): Promise<Address[]> {
+    const vaultsWithDelegatedFarm = await this.getVaultsWithDelegatedFarm();
+    return Array.from(vaultsWithDelegatedFarm.values());
+  }
+
+  /**
+   * This will return a map of the vault address and the delegated farm address for that vault
+   * @returns a map of the vault address and the delegated farm address for that vault
+   */
+  async getVaultsWithDelegatedFarm(): Promise<Map<Address, Address>> {
+    const response = await fetch(`${CDN_ENDPOINT}/resources.json`);
+    if (!response.ok) {
+      console.log(`Failed to fetch CDN for get vaults with delegated farm`);
+      return new Map<Address, Address>();
+    }
+    const data = (await response.json()) as { 'mainnet-beta'?: { delegatedVaultFarms: any } };
+    const delegatedVaultFarms = data['mainnet-beta']?.delegatedVaultFarms;
+    if (!delegatedVaultFarms) {
+      return new Map<Address, Address>();
+    }
+
+    return new Map(
+      delegatedVaultFarms.map((delegatedFarm: any) => [address(delegatedFarm.vault), address(delegatedFarm.farm)])
+    );
+  }
+
   /// reads the pending rewards for a user in the reserves farms of a vault
   /// @param user - the user address
   /// @param vault - the vault

package/src/manager/client_kamino_manager.ts

@@ -48,7 +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';
+import { noopSigner, parseKeypairFile } from '../utils/signer';
 
 dotenv.config({
   path: `.env${process.env.ENV ? '.' + process.env.ENV : ''}`,
@@ -455,7 +455,9 @@ async function main() {
         kaminoVault,
         new PendingVaultAdmin(),
         newAdmin,
-        signer
+        signer,
+        undefined,
+        true
       );
 
       await processTx(
@@ -485,7 +487,12 @@ async function main() {
       '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')
-    .action(async ({ vault, field, value, mode, staging }) => {
+    .option(`--skip-lut-update`, 'If set, it will skip the LUT update')
+    .option(
+      `--lutSigner <string>`,
+      'If set, it will use the provided signer instead of the default one for the LUT update'
+    )
+    .action(async ({ vault, field, value, mode, staging, skipLutUpdate, lutSigner }) => {
       const env = await initEnv(staging);
       const vaultAddress = address(vault);
 
@@ -500,7 +507,20 @@ async function main() {
       const vaultState = await kaminoVault.getState();
       const signer = await env.getSigner({ vaultState });
 
-      const instructions = await kaminoManager.updateVaultConfigIxs(kaminoVault, field, value, signer);
+      let lutSignerOrUndefined = undefined;
+      if (lutSigner) {
+        lutSignerOrUndefined = await parseKeypairFile(lutSigner as string);
+      }
+
+      const shouldSkipLutUpdate = !!skipLutUpdate;
+      const instructions = await kaminoManager.updateVaultConfigIxs(
+        kaminoVault,
+        field,
+        value,
+        signer,
+        lutSignerOrUndefined,
+        shouldSkipLutUpdate
+      );
 
       await processTx(
         env.c,
@@ -576,10 +596,15 @@ async function main() {
     )
     .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 ({ lut, addresses, mode, staging, multisig }) => {
+    .option(`--signer <string>`, 'If set, it will use the provided signer instead of the default one')
+    .action(async ({ lut, addresses, mode, staging, multisig, signer }) => {
       const env = await initEnv(multisig, staging);
       const lutAddress = address(lut);
-
+      let txSigner = await env.getSigner();
+      // if the signer is provided (path to a keypair) we use it, otherwise we use the default one
+      if (signer) {
+        txSigner = await parseKeypairFile(signer as string);
+      }
       const addressesArr = addresses.split(' ').map((a: string) => address(a));
 
       if (mode === 'multisig' && !multisig) {
@@ -593,12 +618,11 @@ async function main() {
         env.kvaultProgramId
       );
 
-      const signer = await env.getSigner();
-      const instructions = await kaminoManager.insertIntoLutIxs(signer, lutAddress, addressesArr);
+      const instructions = await kaminoManager.insertIntoLutIxs(txSigner, lutAddress, addressesArr);
 
       await processTx(
         env.c,
-        signer,
+        txSigner,
         [
           ...instructions,
           ...getPriorityFeeAndCuIxs({
@@ -640,7 +664,8 @@ async function main() {
       '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')
-    .action(async ({ vault, mode, staging }) => {
+    .option(`--signer <string>`, 'If set, it will use the provided signer instead of the default one')
+    .action(async ({ vault, mode, staging, signer }) => {
       const env = await initEnv(staging);
       const vaultAddress = address(vault);
 
@@ -653,14 +678,18 @@ async function main() {
 
       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);
+      let txSigner = await env.getSigner({ vaultState });
+      // if the signer is provided (path to a keypair) we use it, otherwise we use the default one
+      if (signer) {
+        txSigner = await parseKeypairFile(signer as string);
+      }
+      const syncLUTIxs = await kaminoManager.syncVaultLUTIxs(txSigner, kaminoVault);
 
       // if we need to create the LUT we have to do that in a separate tx and wait a little bit after
       if (syncLUTIxs.setupLUTIfNeededIxs.length > 0) {
         await processTx(
           env.c,
-          signer,
+          txSigner,
           [
             ...syncLUTIxs.setupLUTIfNeededIxs,
             ...getPriorityFeeAndCuIxs({
@@ -677,7 +706,7 @@ async function main() {
       for (const ix of syncLUTIxs.syncLUTIxs) {
         await processTx(
           env.c,
-          signer,
+          txSigner,
           [
             ix,
             ...getPriorityFeeAndCuIxs({
@@ -1353,6 +1382,7 @@ async function main() {
         console.log('reserve ', reserveAddress);
         console.log('reserve incentive', incentive);
       });
+      console.log('totalIncentivesAPY', vaultOverview.reservesFarmsIncentives.totalIncentivesAPY.toString());
     });
 
   commands
@@ -1527,6 +1557,35 @@ async function main() {
       }
     });
 
+  commands.command('get-cumulative-delegated-farms-rewards').action(async () => {
+    const env = await initEnv();
+    const kaminoManager = new KaminoManager(
+      env.c.rpc,
+      DEFAULT_RECENT_SLOT_DURATION_MS,
+      env.klendProgramId,
+      env.kvaultProgramId
+    );
+    const cumulativeRewards = await kaminoManager.getCumulativeDelegatedFarmsRewardsIssuedForAllVaults();
+    cumulativeRewards.forEach((reward, tokenMint) => {
+      console.log(`token mint ${tokenMint} rewards issued (lamports) ${reward}`);
+    });
+  });
+
+  commands.command('get-vaults-with-delegated-farm').action(async () => {
+    const env = await initEnv();
+    const kaminoManager = new KaminoManager(
+      env.c.rpc,
+      DEFAULT_RECENT_SLOT_DURATION_MS,
+      env.klendProgramId,
+      env.kvaultProgramId
+    );
+
+    const vaultsWithDelegatedFarm = await kaminoManager.getVaultsWithDelegatedFarm();
+    vaultsWithDelegatedFarm.forEach((delegatedFarm, vault) => {
+      console.log(`vault ${vault} delegated farm ${delegatedFarm}`);
+    });
+  });
+
   commands
     .command('simulate-reserve-apy')
     .requiredOption('--reserve <string>', 'Reserve address')

package/src/utils/lookupTable.ts

@@ -110,11 +110,16 @@ export function closeLookupTableIx(authority: TransactionSigner, lookupTable: Ad
  * Returns the accounts in a lookup table
  * @param rpc
  * @param lookupTable - lookup table to get the accounts from
- * @returns - an array of accounts in the lookup table
+ * @returns - an array of accounts in the lookup table or an empty array if the lookup table does not exist
  */
 export async function getAccountsInLut(rpc: Rpc<GetAccountInfoApi>, lookupTable: Address): Promise<Address[]> {
-  const lutState = await fetchAddressLookupTable(rpc, lookupTable);
-  return lutState.data.addresses;
+  try {
+    const lutState = await fetchAddressLookupTable(rpc, lookupTable);
+    return lutState.data.addresses;
+  } catch (error) {
+    console.error(`Error fetching accounts in lookup table ${lookupTable.toString()}`, error);
+    return [];
+  }
 }
 /**
  * This method inserts the missing keys from the provided keys into an existent lookup table