@kamino-finance/klend-sdk 7.0.2 → 7.0.4

package/src/classes/market.ts

@@ -20,6 +20,7 @@ import { KaminoObligation } from './obligation';
 import { KaminoReserve, KaminoReserveRpcApi } from './reserve';
 import { LendingMarket, Obligation, ReferrerTokenState, Reserve, UserMetadata } from '../@codegen/klend/accounts';
 import {
+  AllOracleAccounts,
   cacheOrGetPythPrices,
   cacheOrGetScopePrice,
   cacheOrGetSwitchboardPrice,
@@ -48,7 +49,7 @@ import { PROGRAM_ID } from '../@codegen/klend/programId';
 import { Scope, U16_MAX } from '@kamino-finance/scope-sdk';
 import { OraclePrices } from '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts/OraclePrices';
 import { Fraction } from './fraction';
-import { chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
+import { batchFetch, chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
 import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
 import { ObligationZP } from '../@codegen/klend/zero_padding';
 import { checkDefined } from '../utils/validations';
@@ -99,6 +100,10 @@ export class KaminoMarket {
     recentSlotDurationMs: number,
     programId: Address = PROGRAM_ID
   ) {
+    if (recentSlotDurationMs <= 0) {
+      throw new Error('Recent slot duration cannot be 0');
+    }
+
     this.address = marketAddress;
     this.rpc = rpc;
     this.state = state;
@@ -134,10 +139,6 @@ export class KaminoMarket {
       return null;
     }
 
-    if (recentSlotDurationMs <= 0) {
-      throw new Error('Recent slot duration cannot be 0');
-    }
-
     const reserves = withReserves
       ? await getReservesForMarket(marketAddress, rpc, programId, recentSlotDurationMs)
       : new Map<Address, KaminoReserve>();
@@ -156,6 +157,68 @@ export class KaminoMarket {
     return new KaminoMarket(connection, market, marketAddress, reserves, recentSlotDurationMs, programId);
   }
 
+  static async loadMultiple(
+    connection: Rpc<KaminoMarketRpcApi>,
+    markets: Address[],
+    recentSlotDurationMs: number,
+    programId: Address = PROGRAM_ID,
+    withReserves: boolean = true,
+    oracleAccounts?: AllOracleAccounts
+  ) {
+    const marketStates = await batchFetch(markets, (market) =>
+      LendingMarket.fetchMultiple(connection, market, programId)
+    );
+    const kaminoMarkets = new Map<Address, KaminoMarket>();
+    for (let i = 0; i < markets.length; i++) {
+      const market = marketStates[i];
+      const marketAddress = markets[i];
+      if (market === null) {
+        throw Error(`Could not fetch LendingMarket account state for market ${marketAddress}`);
+      }
+
+      const marketReserves = withReserves
+        ? await getReservesForMarket(marketAddress, connection, programId, recentSlotDurationMs, oracleAccounts)
+        : new Map<Address, KaminoReserve>();
+
+      kaminoMarkets.set(
+        marketAddress,
+        new KaminoMarket(connection, market, marketAddress, marketReserves, recentSlotDurationMs, programId)
+      );
+    }
+    return kaminoMarkets;
+  }
+
+  static async loadMultipleWithReserves(
+    connection: Rpc<KaminoMarketRpcApi>,
+    markets: Address[],
+    reserves: Map<Address, Map<Address, KaminoReserve>>,
+    recentSlotDurationMs: number,
+    programId: Address = PROGRAM_ID
+  ) {
+    const marketStates = await batchFetch(markets, (market) =>
+      LendingMarket.fetchMultiple(connection, market, programId)
+    );
+    const kaminoMarkets = new Map<Address, KaminoMarket>();
+    for (let i = 0; i < markets.length; i++) {
+      const market = marketStates[i];
+      const marketAddress = markets[i];
+      if (market === null) {
+        throw Error(`Could not fetch LendingMarket account state for market ${marketAddress}`);
+      }
+      const marketReserves = reserves.get(marketAddress);
+      if (!marketReserves) {
+        throw Error(
+          `Could not get reserves for market ${marketAddress} from the reserves map argument supplied to this method`
+        );
+      }
+      kaminoMarkets.set(
+        marketAddress,
+        new KaminoMarket(connection, market, marketAddress, marketReserves, recentSlotDurationMs, programId)
+      );
+    }
+    return kaminoMarkets;
+  }
+
   async reload(): Promise<void> {
     const market = await LendingMarket.fetch(this.rpc, this.getAddress(), this.programId);
     if (market === null) {
@@ -395,7 +458,7 @@ export class KaminoMarket {
       : debtReserve.getMaxBorrowAmountWithCollReserve(this, collReserve, slot);
   }
 
-  async loadReserves() {
+  async loadReserves(oracleAccounts?: AllOracleAccounts) {
     const addresses = [...this.reserves.keys()];
     const reserveAccounts = await this.rpc
       .getMultipleAccounts(addresses, { commitment: 'processed', encoding: 'base64' })
@@ -411,7 +474,7 @@ export class KaminoMarket {
       }
       return reserveAccount;
     });
-    const reservesAndOracles = await getTokenOracleData(this.getRpc(), deserializedReserves);
+    const reservesAndOracles = await getTokenOracleData(this.getRpc(), deserializedReserves, oracleAccounts);
     const kaminoReserves = new Map<Address, KaminoReserve>();
     reservesAndOracles.forEach(([reserve, oracle], index) => {
       if (!oracle) {
@@ -881,9 +944,13 @@ export class KaminoMarket {
     return finalObligations;
   }
 
-  async getAllUserObligations(user: Address, commitment: Commitment = 'processed'): Promise<KaminoObligation[]> {
+  async getAllUserObligations(
+    user: Address,
+    commitment: Commitment = 'processed',
+    slot?: bigint
+  ): Promise<KaminoObligation[]> {
     const [currentSlot, obligations] = await Promise.all([
-      this.rpc.getSlot().send(),
+      slot !== undefined ? Promise.resolve(slot) : this.rpc.getSlot().send(),
       this.rpc
         .getProgramAccounts(this.programId, {
           filters: [
@@ -1261,8 +1328,7 @@ export class KaminoMarket {
   /**
    * Get all Scope prices used by all the market reserves
    */
-  async getAllScopePrices(scope: Scope): Promise<KaminoPrices> {
-    const allOraclePrices = await this.getReserveOraclePrices(scope);
+  async getAllScopePrices(scope: Scope, allOraclePrices: Map<Address, OraclePrices>): Promise<KaminoPrices> {
     const spot: MintToPriceMap = {};
     const twaps: MintToPriceMap = {};
     for (const reserve of this.reserves.values()) {
@@ -1271,7 +1337,7 @@ export class KaminoMarket {
       const oracle = reserve.state.config.tokenInfo.scopeConfiguration.priceFeed;
       const chain = reserve.state.config.tokenInfo.scopeConfiguration.priceChain;
       const twapChain = reserve.state.config.tokenInfo.scopeConfiguration.twapChain.filter((x) => x > 0);
-      const oraclePrices = allOraclePrices.get(reserve.address);
+      const oraclePrices = allOraclePrices.get(oracle);
       if (oraclePrices && oracle && isNotNullPubkey(oracle) && chain && Scope.isScopeChainValid(chain)) {
         const spotPrice = await scope.getPriceFromChain(chain, oraclePrices);
         spot[tokenMint] = { price: spotPrice.price, name: tokenName };
@@ -1287,16 +1353,18 @@ export class KaminoMarket {
   /**
    * Get all Scope/Pyth/Switchboard prices used by all the market reserves
    */
-  async getAllPrices(): Promise<KlendPrices> {
+  async getAllPrices(oracleAccounts?: AllOracleAccounts): Promise<KlendPrices> {
     const klendPrices: KlendPrices = {
       scope: { spot: {}, twap: {} },
       pyth: { spot: {}, twap: {} },
       switchboard: { spot: {}, twap: {} },
     };
-    const allOracleAccounts = await getAllOracleAccounts(
-      this.rpc,
-      this.getReserves().map((x) => x.state)
-    );
+    const allOracleAccounts =
+      oracleAccounts ??
+      (await getAllOracleAccounts(
+        this.rpc,
+        this.getReserves().map((x) => x.state)
+      ));
     const pythCache = new Map<Address, PythPrices>();
     const switchboardCache = new Map<Address, CandidatePrice>();
     const scopeCache = new Map<Address, OraclePrices>();
@@ -1506,7 +1574,8 @@ export async function getReservesForMarket(
   marketAddress: Address,
   rpc: Rpc<KaminoReserveRpcApi>,
   programId: Address,
-  recentSlotDurationMs: number
+  recentSlotDurationMs: number,
+  oracleAccounts?: AllOracleAccounts
 ): Promise<Map<Address, KaminoReserve>> {
   const reserves = await rpc
     .getProgramAccounts(programId, {
@@ -1537,7 +1606,7 @@ export async function getReservesForMarket(
     }
     return reserveAccount;
   });
-  const reservesAndOracles = await getTokenOracleData(rpc, deserializedReserves);
+  const reservesAndOracles = await getTokenOracleData(rpc, deserializedReserves, oracleAccounts);
   const reservesByAddress = new Map<Address, KaminoReserve>();
   reservesAndOracles.forEach(([reserve, oracle], index) => {
     if (!oracle) {
@@ -1553,14 +1622,15 @@ export async function getSingleReserve(
   reservePk: Address,
   rpc: Rpc<KaminoReserveRpcApi>,
   recentSlotDurationMs: number,
-  reserveData?: Reserve
+  reserveData?: Reserve,
+  oracleAccounts?: AllOracleAccounts
 ): Promise<KaminoReserve> {
   const reserve = reserveData ?? (await Reserve.fetch(rpc, reservePk));
 
   if (reserve === null) {
     throw new Error(`Reserve account ${reservePk} does not exist`);
   }
-  const reservesAndOracles = await getTokenOracleData(rpc, [reserve]);
+  const reservesAndOracles = await getTokenOracleData(rpc, [reserve], oracleAccounts);
   const [, oracle] = reservesAndOracles[0];
 
   if (!oracle) {

package/src/classes/reserve.ts

@@ -16,6 +16,7 @@ import {
 } from '@solana/kit';
 import Decimal from 'decimal.js';
 import {
+  AllOracleAccounts,
   DEFAULT_PUBLIC_KEY,
   getTokenOracleData,
   globalConfigPda,
@@ -102,14 +103,15 @@ export class KaminoReserve {
     address: Address,
     rpc: Rpc<KaminoReserveRpcApi>,
     recentSlotDurationMs: number,
-    reserveState?: Reserve
+    reserveState?: Reserve,
+    oracleAccounts?: AllOracleAccounts
   ) {
     const reserve = reserveState ?? (await Reserve.fetch(rpc, address));
     if (reserve === null) {
       throw new Error(`Reserve account ${address} does not exist`);
     }
 
-    const tokenOracleDataWithReserve = await getTokenOracleData(rpc, [reserve]);
+    const tokenOracleDataWithReserve = await getTokenOracleData(rpc, [reserve], oracleAccounts);
     if (!tokenOracleDataWithReserve[0]) {
       throw new Error('Token oracle data not found');
     }

package/src/classes/vault.ts

@@ -23,6 +23,7 @@ import {
   TransactionSigner,
 } from '@solana/kit';
 import {
+  AllOracleAccounts,
   DEFAULT_PUBLIC_KEY,
   DEFAULT_RECENT_SLOT_DURATION_MS,
   getAssociatedTokenAddress,
@@ -124,6 +125,7 @@ import { getExtendLookupTableInstruction } from '@solana-program/address-lookup-
 import { Farms } from '@kamino-finance/farms-sdk';
 import { getFarmIncentives } from '@kamino-finance/farms-sdk/dist/utils/apy';
 import { computeReservesAllocation } from '../utils/vaultAllocation';
+import { getReserveFarmRewardsAPY } from '../utils/farmUtils';
 
 export const kaminoVaultId = address('KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd');
 export const kaminoVaultStagingId = address('stKvQfwRsQiKnLtMNVLHKS3exFJmZFsgfzBPWHECUYK');
@@ -2064,19 +2066,21 @@ export class KaminoVaultClient {
 
   /**
    * This method calculates the token per share value. This will always change based on interest earned from the vault, but calculating it requires a bunch of rpc requests. Caching this for a short duration would be optimal
-   * @param vault - vault to calculate tokensPerShare for
+   * @param vaultState - vault state to calculate tokensPerShare for
    * @param [slot] - the slot at which we retrieve the tokens per share. Optional. If not provided, the function will fetch the current slot
    * @param [vaultReservesMap] - hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @param [currentSlot] - the latest confirmed slot. Optional. If provided the function will be  faster as it will not have to fetch the latest slot
    * @returns - token per share value
    */
   async getTokensPerShareSingleVault(
-    vault: KaminoVault,
+    vaultOrState: KaminoVault | VaultState,
     slot?: Slot,
     vaultReservesMap?: Map<Address, KaminoReserve>,
     currentSlot?: Slot
   ): Promise<Decimal> {
-    const vaultState = await vault.getState(this.getConnection());
+    // Determine if we have a KaminoVault or VaultState
+    const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState(this.getConnection()) : vaultOrState;
+
     if (vaultState.sharesIssued.isZero()) {
       return new Decimal(0);
     }
@@ -2361,9 +2365,13 @@ export class KaminoVaultClient {
   /**
    * This will load the onchain state for all the reserves that the vaults have allocations for, deduplicating the reserves
    * @param vaults - the vault states to load reserves for
+   * @param oracleAccounts (optional) all reserve oracle accounts, if not supplied will make an additional rpc call to fetch these accounts
    * @returns a hashmap from each reserve pubkey to the reserve state
    */
-  async loadVaultsReserves(vaults: VaultState[]): Promise<Map<Address, KaminoReserve>> {
+  async loadVaultsReserves(
+    vaults: VaultState[],
+    oracleAccounts?: AllOracleAccounts
+  ): Promise<Map<Address, KaminoReserve>> {
     const vaultReservesAddressesSet = new Set<Address>(vaults.flatMap((vault) => this.getVaultReserves(vault)));
     const vaultReservesAddresses = [...vaultReservesAddressesSet];
     const reserveAccounts = await this.getConnection()
@@ -2382,7 +2390,7 @@ export class KaminoVaultClient {
       return reserveAccount;
     });
 
-    const reservesAndOracles = await getTokenOracleData(this.getConnection(), deserializedReserves);
+    const reservesAndOracles = await getTokenOracleData(this.getConnection(), deserializedReserves, oracleAccounts);
 
     const kaminoReserves = new Map<Address, KaminoReserve>();
 
@@ -2409,13 +2417,15 @@ export class KaminoVaultClient {
    * @param [slot] - the slot for which to retrieve the vault collaterals for. Optional. If not provided the function will fetch the current slot
    * @param [vaultReservesMap] - hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @param [kaminoMarkets] - a list of all the kamino markets. Optional. If provided the function will be significantly faster as it will not have to fetch the markets
+   * @param oracleAccounts (optional) all reserve oracle accounts, if not supplied will make an additional rpc call to fetch these accounts
    * @returns a hashmap from each reserve pubkey to the market overview of the collaterals that can be used and the min and max loan to value ratio in that market
    */
   async getVaultCollaterals(
     vaultState: VaultState,
     slot: Slot,
     vaultReservesMap?: Map<Address, KaminoReserve>,
-    kaminoMarkets?: KaminoMarket[]
+    kaminoMarkets?: KaminoMarket[],
+    oracleAccounts?: AllOracleAccounts
   ): Promise<Map<Address, MarketOverview>> {
     const vaultReservesStateMap = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
     const vaultReservesState: KaminoReserve[] = [];
@@ -2439,7 +2449,11 @@ export class KaminoVaultClient {
     const missingReservesStates = (await Reserve.fetchMultiple(this.getConnection(), [...missingReserves])).filter(
       (reserve) => reserve !== null
     );
-    const missingReservesAndOracles = await getTokenOracleData(this.getConnection(), missingReservesStates);
+    const missingReservesAndOracles = await getTokenOracleData(
+      this.getConnection(),
+      missingReservesStates,
+      oracleAccounts
+    );
     missingReservesAndOracles.forEach(([reserve, oracle], index) => {
       const fetchedReserve = new KaminoReserve(
         reserve,
@@ -2638,16 +2652,16 @@ export class KaminoVaultClient {
   /**
    * This will return an VaultOverview object that encapsulates all the information about the vault, including the holdings, reserves details, theoretical APY, utilization ratio and total borrowed amount
    * @param vault - the kamino vault to get available liquidity to withdraw for
-   * @param price - the price of the token in the vault (e.g. USDC)
+   * @param vaultTokenPrice - the price of the token in the vault (e.g. USDC)
    * @param [slot] - the slot for which to retrieve the vault overview for. Optional. If not provided the function will fetch the current slot
    * @param [vaultReservesMap] - hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @param [kaminoMarkets] - a list of all kamino markets. Optional. If provided the function will be significantly faster as it will not have to fetch the markets
    * @param [currentSlot] - the latest confirmed slot. Optional. If provided the function will be  faster as it will not have to fetch the latest slot
-   * @returns an VaultOverview object with details about the tokens available and invested in the vault, denominated in tokens and USD
+   * @returns an VaultOverview object with details about the tokens available and invested in the vault, denominated in tokens and USD, along sie APYs
    */
   async getVaultOverview(
     vault: VaultState,
-    price: Decimal,
+    vaultTokenPrice: Decimal,
     slot?: Slot,
     vaultReservesMap?: Map<Address, KaminoReserve>,
     kaminoMarkets?: KaminoMarket[],
@@ -2655,30 +2669,34 @@ export class KaminoVaultClient {
   ): Promise<VaultOverview> {
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vault);
 
-    const vaultHoldingsWithUSDValuePromise = await this.getVaultHoldingsWithPrice(
+    const vaultHoldingsWithUSDValuePromise = this.getVaultHoldingsWithPrice(
       vault,
-      price,
+      vaultTokenPrice,
       slot,
       vaultReservesState,
       currentSlot
     );
 
     const slotForOverview = slot ? slot : await this.getConnection().getSlot().send();
+    const farmsClient = new Farms(this.getConnection());
 
-    const vaultTheoreticalAPYPromise = await this.getVaultTheoreticalAPY(vault, slotForOverview, vaultReservesState);
-    const vaultActualAPYPromise = await this.getVaultActualAPY(vault, slotForOverview, vaultReservesState);
-    const totalInvestedAndBorrowedPromise = await this.getTotalBorrowedAndInvested(
+    const vaultTheoreticalAPYPromise = this.getVaultTheoreticalAPY(vault, slotForOverview, vaultReservesState);
+    const vaultActualAPYPromise = this.getVaultActualAPY(vault, slotForOverview, vaultReservesState);
+    const totalInvestedAndBorrowedPromise = this.getTotalBorrowedAndInvested(
       vault,
       slotForOverview,
       vaultReservesState
     );
-    const vaultCollateralsPromise = await this.getVaultCollaterals(
+    const vaultCollateralsPromise = this.getVaultCollaterals(vault, slotForOverview, vaultReservesState, kaminoMarkets);
+    const reservesOverviewPromise = this.getVaultReservesDetails(vault, slotForOverview, vaultReservesState);
+    const vaultFarmIncentivesPromise = this.getVaultRewardsAPY(vault, vaultTokenPrice, farmsClient, slotForOverview);
+    const vaultReservesFarmIncentivesPromise = this.getVaultReservesFarmsIncentives(
       vault,
+      vaultTokenPrice,
+      farmsClient,
       slotForOverview,
-      vaultReservesState,
-      kaminoMarkets
+      vaultReservesState
     );
-    const reservesOverviewPromise = await this.getVaultReservesDetails(vault, slotForOverview, vaultReservesState);
 
     // all the async part of the functions above just read the vaultReservesState which is read beforehand, so excepting vaultCollateralsPromise they should do no additional network calls
     const [
@@ -2688,6 +2706,8 @@ export class KaminoVaultClient {
       totalInvestedAndBorrowed,
       vaultCollaterals,
       reservesOverview,
+      vaultFarmIncentives,
+      vaultReservesFarmIncentives,
     ] = await Promise.all([
       vaultHoldingsWithUSDValuePromise,
       vaultTheoreticalAPYPromise,
@@ -2695,6 +2715,8 @@ export class KaminoVaultClient {
       totalInvestedAndBorrowedPromise,
       vaultCollateralsPromise,
       reservesOverviewPromise,
+      vaultFarmIncentivesPromise,
+      vaultReservesFarmIncentivesPromise,
     ]);
 
     return {
@@ -2703,11 +2725,13 @@ export class KaminoVaultClient {
       vaultCollaterals: vaultCollaterals,
       actualSupplyAPY: vaultActualAPYs,
       theoreticalSupplyAPY: vaultTheoreticalAPYs,
+      vaultFarmIncentives: vaultFarmIncentives,
+      reservesFarmsIncentives: vaultReservesFarmIncentives,
       totalBorrowed: totalInvestedAndBorrowed.totalBorrowed,
-      totalBorrowedUSD: totalInvestedAndBorrowed.totalBorrowed.mul(price),
+      totalBorrowedUSD: totalInvestedAndBorrowed.totalBorrowed.mul(vaultTokenPrice),
       utilizationRatio: totalInvestedAndBorrowed.utilizationRatio,
       totalSupplied: totalInvestedAndBorrowed.totalInvested,
-      totalSuppliedUSD: totalInvestedAndBorrowed.totalInvested.mul(price),
+      totalSuppliedUSD: totalInvestedAndBorrowed.totalInvested.mul(vaultTokenPrice),
     };
   }
 
@@ -3021,11 +3045,18 @@ export class KaminoVaultClient {
    * Read the APY of the farm built on top of the vault (farm in vaultState.vaultFarm)
    * @param vault - the vault to read the farm APY for
    * @param vaultTokenPrice - the price of the vault token in USD (e.g. 1.0 for USDC)
+   * @param [farmsClient] - the farms client to use. Optional. If not provided, the function will create a new one
    * @param [slot] - the slot to read the farm APY for. Optional. If not provided, the function will read the current slot
    * @returns the APY of the farm built on top of the vault
    */
-  async getVaultRewardsAPY(vault: KaminoVault, vaultTokenPrice: Decimal, slot?: Slot): Promise<FarmIncentives> {
-    const vaultState = await vault.getState(this.getConnection());
+  async getVaultRewardsAPY(
+    vaultOrState: KaminoVault | VaultState,
+    vaultTokenPrice: Decimal,
+    farmsClient?: Farms,
+    slot?: Slot
+  ): Promise<FarmIncentives> {
+    // Determine if we have a KaminoVault or VaultState
+    const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState(this.getConnection()) : vaultOrState;
     if (vaultState.vaultFarm === DEFAULT_PUBLIC_KEY) {
       return {
         incentivesStats: [],
@@ -3033,12 +3064,74 @@ export class KaminoVaultClient {
       };
     }
 
-    const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot);
+    const tokensPerShare = await this.getTokensPerShareSingleVault(vaultState, slot);
     const sharePrice = tokensPerShare.mul(vaultTokenPrice);
     const stakedTokenMintDecimals = vaultState.sharesMintDecimals.toNumber();
 
-    const farmsClient = new Farms(this.getConnection());
-    return getFarmIncentives(farmsClient, vaultState.vaultFarm, sharePrice, stakedTokenMintDecimals);
+    const kFarmsClient = farmsClient ? farmsClient : new Farms(this.getConnection());
+    return getFarmIncentives(kFarmsClient, vaultState.vaultFarm, sharePrice, stakedTokenMintDecimals);
+  }
+
+  async getVaultReservesFarmsIncentives(
+    vaultOrState: KaminoVault | VaultState,
+    vaultTokenPrice: Decimal,
+    farmsClient?: Farms,
+    slot?: Slot,
+    vaultReservesMap?: Map<Address, KaminoReserve>
+  ): Promise<VaultReservesFarmsIncentives> {
+    const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState(this.getConnection()) : vaultOrState;
+
+    const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+    const currentSlot = slot ? slot : await this.getConnection().getSlot({ commitment: 'confirmed' }).send();
+
+    const holdings = await this.getVaultHoldings(vaultState, currentSlot, vaultReservesState);
+
+    const vaultReservesAddresses = vaultState.vaultAllocationStrategy.map(
+      (allocationStrategy) => allocationStrategy.reserve
+    );
+
+    const vaultReservesFarmsIncentives = new Map<Address, FarmIncentives>();
+    let totalIncentivesApy = new Decimal(0);
+
+    const kFarmsClient = farmsClient ? farmsClient : new Farms(this.getConnection());
+    for (const reserveAddress of vaultReservesAddresses) {
+      if (reserveAddress === DEFAULT_PUBLIC_KEY) {
+        continue;
+      }
+
+      const reserveState = vaultReservesState.get(reserveAddress);
+      if (reserveState === undefined) {
+        console.log(`Reserve to read farm incentives for not found: ${reserveAddress}`);
+        vaultReservesFarmsIncentives.set(reserveAddress, {
+          incentivesStats: [],
+          totalIncentivesApy: 0,
+        });
+        continue;
+      }
+
+      const reserveFarmIncentives = await getReserveFarmRewardsAPY(
+        this._rpc,
+        this.recentSlotDurationMs,
+        reserveAddress,
+        vaultTokenPrice,
+        this._kaminoLendProgramId,
+        kFarmsClient,
+        currentSlot,
+        reserveState.state
+      );
+      vaultReservesFarmsIncentives.set(reserveAddress, reserveFarmIncentives.collateralFarmIncentives);
+
+      const investedInReserve = holdings.investedInReserves.get(reserveAddress);
+      const weightedReserveAPY = new Decimal(reserveFarmIncentives.collateralFarmIncentives.totalIncentivesApy)
+        .mul(investedInReserve ?? 0)
+        .div(holdings.totalAUMIncludingFees);
+      totalIncentivesApy = totalIncentivesApy.add(weightedReserveAPY);
+    }
+
+    return {
+      reserveFarmsIncentives: vaultReservesFarmsIncentives,
+      totalIncentivesAPY: totalIncentivesApy,
+    };
   }
 
   private appendRemainingAccountsForVaultReserves(
@@ -3275,6 +3368,8 @@ export type VaultOverview = {
   vaultCollaterals: Map<Address, MarketOverview>;
   theoreticalSupplyAPY: APYs;
   actualSupplyAPY: APYs;
+  vaultFarmIncentives: FarmIncentives;
+  reservesFarmsIncentives: VaultReservesFarmsIncentives;
   totalBorrowed: Decimal;
   totalBorrowedUSD: Decimal;
   totalSupplied: Decimal;
@@ -3282,6 +3377,11 @@ export type VaultOverview = {
   utilizationRatio: Decimal;
 };
 
+export type VaultReservesFarmsIncentives = {
+  reserveFarmsIncentives: Map<Address, FarmIncentives>;
+  totalIncentivesAPY: Decimal;
+};
+
 export type VaultFeesPct = {
   managementFeePct: Decimal;
   performanceFeePct: Decimal;

package/src/client/commands/initFarmsForReserve.ts

@@ -1,5 +1,6 @@
 import { Address, generateKeyPairSigner, TransactionSigner } from '@solana/kit';
 import {
+  DEFAULT_RECENT_SLOT_DURATION_MS,
   initFarmsForReserve as initFarmsForReserveIx,
   KaminoMarket,
   lendingMarketAuthPda,
@@ -11,7 +12,6 @@ import { getCreateAccountInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-pro
 import { SYSVAR_RENT_ADDRESS } from '@solana/sysvars';
 import { CliEnv, SendTxMode } from '../tx/CliEnv';
 import { processTx } from '../tx/processor';
-import { DEFAULT_RECENT_SLOT_DURATION_MS } from '@kamino-finance/klend-sdk';
 
 export async function initFarmsForReserve(
   env: CliEnv,

package/src/manager/client_kamino_manager.ts

@@ -1318,6 +1318,10 @@ async function main() {
       );
 
       console.log('vaultOverview', vaultOverview);
+      vaultOverview.reservesFarmsIncentives.reserveFarmsIncentives.forEach((incentive, reserveAddress) => {
+        console.log('reserve ', reserveAddress);
+        console.log('reserve incentive', incentive);
+      });
     });
 
   commands

package/src/utils/farmUtils.ts

@@ -0,0 +1,73 @@
+import { Address, Rpc, Slot, SolanaRpcApi } from '@solana/kit';
+import { Decimal } from 'decimal.js';
+import { FarmIncentives, Farms } from '@kamino-finance/farms-sdk';
+import { getFarmIncentives } from '@kamino-finance/farms-sdk/dist/utils/apy';
+import { DEFAULT_PUBLIC_KEY } from '@kamino-finance/farms-sdk';
+import { Reserve } from '../@codegen/klend/accounts';
+import { KaminoReserve } from '../lib';
+import { getMintDecimals } from '@kamino-finance/kliquidity-sdk';
+
+export interface ReserveIncentives {
+  collateralFarmIncentives: FarmIncentives;
+  debtFarmIncentives: FarmIncentives;
+}
+
+export async function getReserveFarmRewardsAPY(
+  rpc: Rpc<SolanaRpcApi>,
+  recentSlotDurationMs: number,
+  reserve: Address,
+  reserveLiquidityTokenPrice: Decimal,
+  kaminoLendProgramId: Address,
+  farmsClient: Farms,
+  slot: Slot,
+  reserveState?: Reserve,
+  cTokenMintDecimals?: number
+): Promise<ReserveIncentives> {
+  const reserveIncentives: ReserveIncentives = {
+    collateralFarmIncentives: {
+      incentivesStats: [],
+      totalIncentivesApy: 0,
+    },
+    debtFarmIncentives: {
+      incentivesStats: [],
+      totalIncentivesApy: 0,
+    },
+  };
+
+  const reserveAccount = reserveState ? reserveState : await Reserve.fetch(rpc, reserve, kaminoLendProgramId);
+  if (!reserveAccount) {
+    throw new Error(`Reserve ${reserve} not found`);
+  }
+
+  const kaminoReserve = await KaminoReserve.initializeFromAddress(reserve, rpc, recentSlotDurationMs, reserveAccount);
+
+  const farmCollateral = kaminoReserve.state.farmCollateral;
+  const farmDebt = kaminoReserve.state.farmDebt;
+
+  const stakedTokenMintDecimals = kaminoReserve.getMintDecimals();
+  const reserveCtokenPrice = reserveLiquidityTokenPrice.div(kaminoReserve.getEstimatedCollateralExchangeRate(slot, 0));
+  const cTokenMint = kaminoReserve.getCTokenMint();
+  const cTokenDecimals = cTokenMintDecimals ? cTokenMintDecimals : await getMintDecimals(rpc, cTokenMint);
+
+  if (farmCollateral !== DEFAULT_PUBLIC_KEY) {
+    const farmIncentivesCollateral = await getFarmIncentives(
+      farmsClient,
+      farmCollateral,
+      reserveCtokenPrice,
+      cTokenDecimals
+    );
+    reserveIncentives.collateralFarmIncentives = farmIncentivesCollateral;
+  }
+
+  if (farmDebt !== DEFAULT_PUBLIC_KEY) {
+    const farmIncentivesDebt = await getFarmIncentives(
+      farmsClient,
+      farmDebt,
+      reserveLiquidityTokenPrice,
+      stakedTokenMintDecimals
+    );
+    reserveIncentives.debtFarmIncentives = farmIncentivesDebt;
+  }
+
+  return reserveIncentives;
+}

package/src/utils/oracle.ts

@@ -105,9 +105,10 @@ export function getTokenOracleDataSync(allOracleAccounts: AllOracleAccounts, res
 // TODO: Add freshness of the latest price to match sc logic
 export async function getTokenOracleData(
   rpc: Rpc<GetMultipleAccountsApi>,
-  reserves: Reserve[]
+  reserves: Reserve[],
+  oracleAccounts?: AllOracleAccounts
 ): Promise<Array<[Reserve, TokenOracleData | undefined]>> {
-  const allOracleAccounts = await getAllOracleAccounts(rpc, reserves);
+  const allOracleAccounts = oracleAccounts ?? (await getAllOracleAccounts(rpc, reserves));
   return getTokenOracleDataSync(allOracleAccounts, reserves);
 }