@kamino-finance/klend-sdk 7.1.4-beta.0 → 7.1.5

package/src/classes/manager.ts

@@ -33,6 +33,7 @@ import {
 } from './vault';
 import {
   AddAssetToMarketParams,
+  AllOracleAccounts,
   CreateKaminoMarketParams,
   createReserveIxs,
   DEFAULT_PUBLIC_KEY,
@@ -1278,10 +1279,14 @@ export class KaminoManager {
   /**
    * 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>> {
-    return this._vaultClient.loadVaultsReserves(vaults);
+  async loadVaultsReserves(
+    vaults: VaultState[],
+    oracleAccounts?: AllOracleAccounts
+  ): Promise<Map<Address, KaminoReserve>> {
+    return this._vaultClient.loadVaultsReserves(vaults, oracleAccounts);
   }
 
   /**
@@ -1566,17 +1571,6 @@ export const MARKET_UPDATER = new ConfigUpdater(UpdateLendingMarketMode.fromDeco
   [UpdateLendingMarketMode.UpdateInitialDepositAmount.kind]: config.minInitialDepositAmount,
   [UpdateLendingMarketMode.UpdateObligationOrderCreationEnabled.kind]: config.obligationOrderCreationEnabled,
   [UpdateLendingMarketMode.UpdateObligationOrderExecutionEnabled.kind]: config.obligationOrderExecutionEnabled,
-  [UpdateLendingMarketMode.UpdateMatureReserveDebtLiquidationEnabled.kind]: config.matureReserveDebtLiquidationEnabled,
-  [UpdateLendingMarketMode.UpdateObligationBorrowDebtTermLiquidationEnabled.kind]:
-    config.obligationBorrowDebtTermLiquidationEnabled,
-  [UpdateLendingMarketMode.UpdateProposerAuthority.kind]: config.proposerAuthority,
-  [UpdateLendingMarketMode.UpdateBorrowOrderCreationEnabled.kind]: config.borrowOrderCreationEnabled,
-  [UpdateLendingMarketMode.UpdateBorrowOrderExecutionEnabled.kind]: config.borrowOrderExecutionEnabled,
-  [UpdateLendingMarketMode.UpdatePriceTriggeredLiquidationDisabled.kind]: config.priceTriggeredLiquidationDisabled,
-  [UpdateLendingMarketMode.UpdateUnstakingPoolState.kind]: config.unstakingPoolState,
-  [UpdateLendingMarketMode.UpdateWithdrawTicketIssuanceEnabled.kind]: config.withdrawTicketIssuanceEnabled,
-  [UpdateLendingMarketMode.UpdateWithdrawTicketRedemptionEnabled.kind]: config.withdrawTicketRedemptionEnabled,
-  [UpdateLendingMarketMode.UpdateMinWithdrawQueuedLiquidityValue.kind]: config.minWithdrawQueuedLiquidityValue,
 }));
 
 function parseForChangesMarketConfigAndGetIxs(

package/src/classes/market.ts

@@ -54,8 +54,6 @@ import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
 import { ObligationZP } from '../@codegen/klend/zero_padding';
 import { checkDefined } from '../utils/validations';
 import { Buffer } from 'buffer';
-import { UNSTAKING_POOL_STAGING_ID, unstakingPoolMintPda } from './unstakingPool';
-import { PROGRAM_ID as UNSTAKING_POOL_ID } from '../@codegen/unstaking_pool/programId';
 
 export type KaminoMarketRpcApi = GetAccountInfoApi &
   GetMultipleAccountsApi &
@@ -66,9 +64,6 @@ export type KaminoMarketRpcApi = GetAccountInfoApi &
   GetBalanceApi;
 
 const base58Decoder = getBase58Decoder();
-// This is a list of reserves (for STAGING only) that were incorrectly initialized and mess up with the mapping from mint -> reserve
-// This can be removed once we migrate all ixs to act upon reserve pubkey instead of mints
-export const INCORRECT_RESERVES_STAGING: Address[] = [address('5JPmNb5oxRZF4yp3kQL44HWmZnbyjguRVZbo2ew6FoxV')];
 
 export interface ReserveRewardInfo {
   rewardsPerSecond: Decimal; // not lamport
@@ -235,15 +230,8 @@ export class KaminoMarket {
     this.reservesActive = getReservesActive(this.reserves);
   }
 
-  async reloadSingleReserve(reservePk: Address, reserveData?: Reserve, programId: Address = PROGRAM_ID): Promise<void> {
-    const reserve = await getSingleReserve(
-      reservePk,
-      this.rpc,
-      this.recentSlotDurationMs,
-      reserveData,
-      undefined,
-      programId
-    );
+  async reloadSingleReserve(reservePk: Address, reserveData?: Reserve): Promise<void> {
+    const reserve = await getSingleReserve(reservePk, this.rpc, this.recentSlotDurationMs, reserveData);
     this.reserves.set(reservePk, reserve);
     this.reservesActive.set(reservePk, reserve);
   }
@@ -256,20 +244,6 @@ export class KaminoMarket {
     return this.address;
   }
 
-  getUsolPoolAddress(): Address {
-    return this.state.unstakingPoolState;
-  }
-
-  getUsolPoolProgramId(): Address {
-    return this.programId == PROGRAM_ID ? UNSTAKING_POOL_ID : UNSTAKING_POOL_STAGING_ID;
-  }
-
-  async getUsolPoolMint(): Promise<Address> {
-    const usolPoolPk = this.getUsolPoolAddress();
-    const usolPoolProgram = this.getUsolPoolProgramId();
-    return (await unstakingPoolMintPda(usolPoolPk, usolPoolProgram))[0];
-  }
-
   /**
    * Get a list of reserves for this market
    */
@@ -1610,7 +1584,7 @@ export async function getReservesForMarket(
   recentSlotDurationMs: number,
   oracleAccounts?: AllOracleAccounts
 ): Promise<Map<Address, KaminoReserve>> {
-  let reserves = await rpc
+  const reserves = await rpc
     .getProgramAccounts(programId, {
       filters: [
         {
@@ -1627,10 +1601,6 @@ export async function getReservesForMarket(
       encoding: 'base64',
     })
     .send();
-  // If staging env always filter the incorrect reserves
-  if (programId !== PROGRAM_ID) {
-    reserves = reserves.filter((reserve) => INCORRECT_RESERVES_STAGING.includes(reserve.pubkey) === false);
-  }
   const deserializedReserves: ReserveWithAddress[] = reserves.map((reserve) => {
     if (reserve.account === null) {
       throw new Error(`Reserve account ${reserve.pubkey} does not exist`);
@@ -1667,10 +1637,9 @@ export async function getSingleReserve(
   rpc: Rpc<KaminoReserveRpcApi>,
   recentSlotDurationMs: number,
   reserveData?: Reserve,
-  oracleAccounts?: AllOracleAccounts,
-  programId: Address = PROGRAM_ID
+  oracleAccounts?: AllOracleAccounts
 ): Promise<KaminoReserve> {
-  const reserve = reserveData ?? (await Reserve.fetch(rpc, reservePk, programId));
+  const reserve = reserveData ?? (await Reserve.fetch(rpc, reservePk));
 
   if (reserve === null) {
     throw new Error(`Reserve account ${reservePk} does not exist`);

package/src/classes/obligation.ts

@@ -270,7 +270,7 @@ export class KaminoObligation {
    * Returns obligation orders (including the null ones, i.e. non-active positions in the orders' array).
    */
   getOrders(): Array<KaminoObligationOrder | null> {
-    return this.state.obligationOrders.map((order) => KaminoObligationOrder.fromState(order));
+    return this.state.orders.map((order) => KaminoObligationOrder.fromState(order));
   }
 
   /**

package/src/classes/reserve.ts

@@ -144,7 +144,7 @@ export class KaminoReserve {
    * @returns the available liquidity amount of the reserve in lamports
    */
   getLiquidityAvailableAmount(): Decimal {
-    return new Decimal(this.state.liquidity.totalAvailableAmount.toString());
+    return new Decimal(this.state.liquidity.availableAmount.toString());
   }
 
   /**
@@ -199,7 +199,7 @@ export class KaminoReserve {
    * @returns the origination fee percentage of the reserve
    */
   getBorrowFee = (): Decimal => {
-    return new Fraction(this.state.config.fees.originationFeeSf).toDecimal();
+    return new Fraction(this.state.config.fees.borrowFeeSf).toDecimal();
   };
 
   /**
@@ -1163,12 +1163,13 @@ export async function createReserveIxs(
 
   const { liquiditySupplyVault, collateralMint, collateralSupplyVault, feeVault } = await reservePdas(
     programId,
-    reserveAddress.address
+    lendingMarket,
+    liquidityMint
   );
   const [lendingMarketAuthority] = await lendingMarketAuthPda(lendingMarket, programId);
 
   const accounts: InitReserveAccounts = {
-    signer: owner,
+    lendingMarketOwner: owner,
     lendingMarket: lendingMarket,
     lendingMarketAuthority: lendingMarketAuthority,
     reserve: reserveAddress.address,
@@ -1221,7 +1222,7 @@ export const RESERVE_CONFIG_UPDATER = new ConfigUpdater(UpdateConfigMode.fromDec
   [UpdateConfigMode.UpdateLiquidationThresholdPct.kind]: config.liquidationThresholdPct,
   [UpdateConfigMode.UpdateProtocolLiquidationFee.kind]: config.protocolLiquidationFeePct,
   [UpdateConfigMode.UpdateProtocolTakeRate.kind]: config.protocolTakeRatePct,
-  [UpdateConfigMode.UpdateFeesOriginationFee.kind]: config.fees.originationFeeSf,
+  [UpdateConfigMode.UpdateFeesBorrowFee.kind]: config.fees.borrowFeeSf,
   [UpdateConfigMode.UpdateFeesFlashLoanFee.kind]: config.fees.flashLoanFeeSf,
   [UpdateConfigMode.DeprecatedUpdateFeesReferralFeeBps.kind]: [], // deprecated
   [UpdateConfigMode.UpdateDepositLimit.kind]: config.depositLimit,
@@ -1255,7 +1256,7 @@ export const RESERVE_CONFIG_UPDATER = new ConfigUpdater(UpdateConfigMode.fromDec
   [UpdateConfigMode.UpdateMinLiquidationBonusBps.kind]: config.minLiquidationBonusBps,
   [UpdateConfigMode.UpdateDeleveragingMarginCallPeriod.kind]: config.deleveragingMarginCallPeriodSecs,
   [UpdateConfigMode.UpdateBorrowFactor.kind]: config.borrowFactorPct,
-  [UpdateConfigMode.DeprecatedUpdateAssetTier.kind]: [], //deprecated
+  [UpdateConfigMode.UpdateAssetTier.kind]: config.assetTier,
   [UpdateConfigMode.UpdateElevationGroup.kind]: config.elevationGroups,
   [UpdateConfigMode.UpdateDeleveragingThresholdDecreaseBpsPerDay.kind]: config.deleveragingThresholdDecreaseBpsPerDay,
   [UpdateConfigMode.DeprecatedUpdateMultiplierSideBoost.kind]: [], // deprecated
@@ -1273,12 +1274,6 @@ export const RESERVE_CONFIG_UPDATER = new ConfigUpdater(UpdateConfigMode.fromDec
   [UpdateConfigMode.UpdateAutodeleverageEnabled.kind]: config.autodeleverageEnabled,
   [UpdateConfigMode.UpdateDeleveragingBonusIncreaseBpsPerDay.kind]: config.deleveragingBonusIncreaseBpsPerDay,
   [UpdateConfigMode.UpdateProtocolOrderExecutionFee.kind]: config.protocolOrderExecutionFeePct,
-  [UpdateConfigMode.UpdateDebtMaturityTimestamp.kind]: config.debtMaturityTimestamp,
-  [UpdateConfigMode.UpdateDebtTermSeconds.kind]: config.debtTermSeconds,
-  [UpdateConfigMode.UpdateProposerAuthorityLock.kind]: config.proposerAuthorityLocked,
-  [UpdateConfigMode.UpdateMinDeleveragingBonusBps.kind]: config.minDeleveragingBonusBps,
-  [UpdateConfigMode.UpdateCanUnstakeLstCollateral.kind]: config.canUnstakeLstCollateral,
-  [UpdateConfigMode.UpdateLtvLamportsMargin.kind]: config.ltvLamportsMargin,
 }));
 
 export async function updateEntireReserveConfigIx(
@@ -1350,7 +1345,7 @@ const NON_VALIDATED_DISCRIMINATORS = [
 function shouldSkipValidation(mode: UpdateConfigModeKind, reserve: Reserve | undefined): boolean {
   return (
     NON_VALIDATED_DISCRIMINATORS.includes(mode.discriminator) &&
-    !reserve?.liquidity.totalAvailableAmount.gten(MIN_INITIAL_DEPOSIT)
+    !reserve?.liquidity.availableAmount.gten(MIN_INITIAL_DEPOSIT)
   );
 }
 

package/src/classes/unstakingPool.ts

@@ -17,7 +17,6 @@ import { TOKEN_2022_PROGRAM_ADDRESS } from '@solana-program/token-2022';
 import { getAssociatedTokenAddress } from '../lib';
 import { PoolState, UnstakeTicket } from '../@codegen/unstaking_pool/accounts';
 import {
-  createAssociatedTokenAccountIdempotentInstruction,
   createLookupTableIx,
   DEFAULT_PUBLIC_KEY,
   extendLookupTableIxs,
@@ -50,7 +49,6 @@ import {
   Rpc,
   SolanaRpcApi,
   TransactionSigner,
-  getBase58Decoder,
 } from '@solana/kit';
 import { getCreateAccountInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
 import { SYSVAR_CLOCK_ADDRESS, SYSVAR_INSTRUCTIONS_ADDRESS, SYSVAR_RENT_ADDRESS } from '@solana/sysvars';
@@ -64,29 +62,16 @@ const STAKE_HISTORY_PROGRAM_ID: Address = address('SysvarStakeHistory11111111111
 const STAKE_ACCOUNT_SIZE: number = 200;
 export const STAKE_POOL_SIZE: number = 611;
 const addressEncoder = getAddressEncoder();
-const base58Decoder = getBase58Decoder();
 
 /**
  * Unstaking sol mint seed
  */
 export const UNSTAKING_SOL_MINT_SEED = Buffer.from('unstaking_sol_mint');
 
-/**
- * Unstaking sol mint seed
- */
-export const UNSTAKING_SOL_WSOL_VAULT_SEED = Buffer.from('wsol_vault');
-
 /**
  * Unstaking sol pool base authority seed
  */
-export const BASE_POOL_AUTHORITY_SEED = Buffer.from('base_authority');
-
-/**
- * Unstaking sol pool lending market authority seed
- */
-export const UNSTAKING_POOL_AUTHORITY_SEED = Buffer.from('upa');
-
-/**
+export const BASE_POOL_AUTHORITY_SEED = Buffer.from('authority');
 
 /**
  * KaminoPoolClient is a class that provides a high-level interface to interact with the Kamino Pool program.
@@ -127,8 +112,8 @@ export class UnstakingPoolClient {
     });
 
     const unstakingSolMint = (await unstakingPoolMintPda(poolState.address))[0];
-    const basePoolAuthority = (await unstakingPoolBaseAuthorityPda(poolState.address))[0];
-    const wsolVault = (await unstakingPoolWsolVaultPda(poolState.address))[0];
+    const basePoolAuthority = (await unstakingPoolAuthorityPda(poolState.address))[0];
+    const wsolVault = await getAssociatedTokenAddress(WRAPPED_SOL_MINT, basePoolAuthority);
 
     const initPoolAccounts: InitializePoolAccounts = {
       admin: poolConfig.admin,
@@ -291,7 +276,6 @@ export class UnstakingPoolClient {
    * @param stakedSolMint - staked sol mint
    * @param stakedSolToDeposit - staked sol to convert to USOL (at the pool ratio)
    * @param minSharesToReceive - parameter to control slippage
-   * @param initUsolAta - pass if you want the usol ata initialized
    * @returns burn instruction
    */
   async mintIx(
@@ -301,8 +285,7 @@ export class UnstakingPoolClient {
     unstakeTicket: TransactionSigner,
     stakedSolMint: Address,
     stakedSolToDeposit: BN,
-    minSharesToReceive: BN,
-    initUsolAta: boolean
+    minSharesToReceive: BN
   ): Promise<MintIxs> {
     const pool = await poolState.getState(this.getConnection());
     // Create unstake ticket ix
@@ -357,17 +340,7 @@ export class UnstakingPoolClient {
       accounts: ixAccounts.concat(remainingAccounts),
       data: ix.data,
     };
-    const ixs = [createUnstakeTicketIx, mintIx];
-    if (initUsolAta) {
-      const [_, createAtaIx] = await createAssociatedTokenAccountIdempotentInstruction(
-        user,
-        pool.unstakingSolMint,
-        user.address,
-        TOKEN_PROGRAM_ADDRESS
-      );
-      ixs.splice(1, 0, createAtaIx);
-    }
-    return { mintIxs: ixs, additionalSigners: remainingSigners };
+    return { mintIxs: [createUnstakeTicketIx, mintIx], additionalSigners: remainingSigners };
   }
 
   /**
@@ -494,46 +467,6 @@ export class UnstakingPool {
   }
 }
 
-export async function getAllTicketsForUser(
-  rpc: Rpc<GetProgramAccountsApi>,
-  user: Address,
-  programId: Address = UNSTAKING_POOL_ID
-): Promise<Array<UnstakeTicketInfo>> {
-  const results = await rpc
-    .getProgramAccounts(programId, {
-      filters: [
-        {
-          dataSize: BigInt(UnstakeTicket.layout.span + 8),
-        },
-        {
-          memcmp: {
-            offset: 0n,
-            bytes: base58Decoder.decode(UnstakeTicket.discriminator) as Base58EncodedBytes,
-            encoding: 'base58',
-          },
-        },
-        {
-          memcmp: {
-            offset: 8n,
-            bytes: user.toString() as Base58EncodedBytes,
-            encoding: 'base58',
-          },
-        },
-      ],
-      encoding: 'base64',
-    })
-    .send();
-
-  return results.map((result) => {
-    return { state: UnstakeTicket.decode(Buffer.from(result.account.data[0], 'base64')), pk: result.pubkey };
-  });
-}
-
-export type UnstakeTicketInfo = {
-  pk: Address;
-  state: UnstakeTicket;
-};
-
 export type StakeAccountInfo = {
   pk: Address;
   stakeAccount: StakeAccount;
@@ -560,17 +493,7 @@ export function unstakingPoolMintPda(
   });
 }
 
-export function unstakingPoolWsolVaultPda(
-  pool: Address,
-  programId: Address = UNSTAKING_POOL_ID
-): Promise<ProgramDerivedAddress> {
-  return getProgramDerivedAddress({
-    seeds: [UNSTAKING_SOL_WSOL_VAULT_SEED, addressEncoder.encode(pool)],
-    programAddress: programId,
-  });
-}
-
-export function unstakingPoolBaseAuthorityPda(
+export function unstakingPoolAuthorityPda(
   pool: Address,
   programId: Address = UNSTAKING_POOL_ID
 ): Promise<ProgramDerivedAddress> {

package/src/classes/vault.ts

@@ -21,6 +21,9 @@ import {
   Slot,
   SolanaRpcApi,
   TransactionSigner,
+  AccountInfoWithPubkey,
+  AccountInfoBase,
+  AccountInfoWithJsonData,
 } from '@solana/kit';
 import {
   AllOracleAccounts,
@@ -77,7 +80,10 @@ import { Fraction } from './fraction';
 import {
   createAtasIdempotent,
   createWsolAtaIfMissing,
+  getAllStandardTokenProgramTokenAccounts,
   getKVaultSharesMetadataPda,
+  getTokenAccountAmount,
+  getTokenAccountMint,
   lendingMarketAuthPda,
   SECONDS_PER_YEAR,
   U64_MAX,
@@ -112,12 +118,7 @@ import {
 import { getCreateAccountInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
 import { getInitializeKVaultSharesMetadataIx, getUpdateSharesMetadataIx, resolveMetadata } from '../utils/metadata';
 import { decodeVaultState } from '../utils/vault';
-import {
-  fetchAllMaybeToken,
-  fetchMaybeToken,
-  findAssociatedTokenPda,
-  getCloseAccountInstruction,
-} from '@solana-program/token-2022';
+import { fetchMaybeToken, findAssociatedTokenPda, getCloseAccountInstruction } from '@solana-program/token-2022';
 import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
 import { SYSVAR_INSTRUCTIONS_ADDRESS, SYSVAR_RENT_ADDRESS } from '@solana/sysvars';
 import { noopSigner } from '../utils/signer';
@@ -1937,15 +1938,22 @@ export class KaminoVaultClient {
       stakedShares: new Decimal(0),
       totalShares: new Decimal(0),
     };
-    const userSharesAta = await getAssociatedTokenAddress(vaultState.sharesMint, user);
-    const userSharesAccountInfo = await fetchMaybeToken(this.getConnection(), userSharesAta);
-    if (userSharesAccountInfo.exists) {
-      const userSharesAccount = userSharesAccountInfo.data;
 
-      userShares.unstakedShares = new Decimal(userSharesAccount.amount.toString()).div(
-        new Decimal(10).pow(vaultState.sharesMintDecimals.toString())
-      );
-    }
+    const userSharesTokenAccounts = await getAllStandardTokenProgramTokenAccounts(this.getConnection(), user);
+
+    const userSharesTokenAccount = userSharesTokenAccounts.filter((tokenAccount) => {
+      const accountData = tokenAccount.account.data;
+      const mint = getTokenAccountMint(accountData);
+      return mint === vaultState.sharesMint;
+    });
+    userShares.unstakedShares = userSharesTokenAccount.reduce((acc, tokenAccount) => {
+      const accountData = tokenAccount.account.data;
+      const amount = getTokenAccountAmount(accountData);
+      if (amount !== null) {
+        return acc.add(new Decimal(amount));
+      }
+      return acc;
+    }, new Decimal(0));
 
     if (await vault.hasFarm(this.getConnection())) {
       const userSharesInFarm = await getUserSharesInTokensStakedInFarm(
@@ -1984,14 +1992,23 @@ export class KaminoVaultClient {
     // stores vault address for each userSharesAta
     const vaultUserShareBalance = new Map<Address, UserSharesForVault>();
 
-    const userSharesAtaArray: Address[] = [];
+    const allUserTokenAccounts = await getAllStandardTokenProgramTokenAccounts(this.getConnection(), user);
+    const userSharesTokenAccountsPerVault = new Map<
+      Address,
+      AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithJsonData>[]
+    >();
     vaults.forEach(async (vault) => {
       const state = vault.state;
       if (!state) {
         throw new Error(`Vault ${vault.address} not fetched`);
       }
-      const userSharesAta = await getAssociatedTokenAddress(state.sharesMint, user);
-      userSharesAtaArray.push(userSharesAta);
+
+      const userSharesTokenAccounts = allUserTokenAccounts.filter((tokenAccount) => {
+        const accountData = tokenAccount.account.data;
+        const mint = getTokenAccountMint(accountData);
+        return mint === state.sharesMint;
+      });
+      userSharesTokenAccountsPerVault.set(vault.address, userSharesTokenAccounts);
 
       if (await vault.hasFarm(this.getConnection())) {
         const userFarmState = allUserFarmStatesMap.get(state.vaultFarm);
@@ -2015,27 +2032,29 @@ export class KaminoVaultClient {
       }
     });
 
-    const userSharesAtaAccounts = await fetchAllMaybeToken(this.getConnection(), userSharesAtaArray);
-
-    userSharesAtaAccounts.forEach((userShareAtaAccount, index) => {
-      let userSharesForVault = vaultUserShareBalance.get(vaults[index].address);
-      if (!userSharesForVault) {
-        userSharesForVault = {
-          unstakedShares: new Decimal(0),
-          stakedShares: new Decimal(0),
-          totalShares: new Decimal(0),
-        };
-      }
+    userSharesTokenAccountsPerVault.forEach((userSharesTokenAccounts, vaultAddress) => {
+      userSharesTokenAccounts.forEach((userSharesTokenAccount) => {
+        let userSharesForVault = vaultUserShareBalance.get(vaultAddress);
+        if (!userSharesForVault) {
+          userSharesForVault = {
+            unstakedShares: new Decimal(0),
+            stakedShares: new Decimal(0),
+            totalShares: new Decimal(0),
+          };
+        }
 
-      if (!userShareAtaAccount.exists) {
-        vaultUserShareBalance.set(vaults[index].address, userSharesForVault);
-      } else {
-        userSharesForVault.unstakedShares = new Decimal(userShareAtaAccount.data.amount.toString()).div(
-          new Decimal(10).pow(vaults[index].state!.sharesMintDecimals.toString())
-        );
-        userSharesForVault.totalShares = userSharesForVault.unstakedShares.add(userSharesForVault.stakedShares);
-        vaultUserShareBalance.set(vaults[index].address, userSharesForVault);
-      }
+        if (!userSharesTokenAccount) {
+          vaultUserShareBalance.set(vaultAddress, userSharesForVault);
+        } else {
+          const accountData = userSharesTokenAccount.account.data;
+          const amount = getTokenAccountAmount(accountData);
+          if (amount !== null) {
+            userSharesForVault.unstakedShares = new Decimal(amount);
+            userSharesForVault.totalShares = userSharesForVault.unstakedShares.add(userSharesForVault.stakedShares);
+            vaultUserShareBalance.set(vaultAddress, userSharesForVault);
+          }
+        }
+      });
     });
 
     return vaultUserShareBalance;
@@ -2351,23 +2370,11 @@ export class KaminoVaultClient {
     return this.loadVaultsReserves([vaultState]);
   }
 
-  /**
-   * 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[],
-    oracleAccounts?: AllOracleAccounts
-  ): Promise<Map<Address, KaminoReserve>> {
-    const vaultReservesAddressesSet = new Set<Address>(vaults.flatMap((vault) => this.getVaultReserves(vault)));
-    const vaultReservesAddresses = [...vaultReservesAddressesSet];
+  private async loadReserializedReserves(vaultReservesAddresses: Address[]) {
     const reserveAccounts = await this.getConnection()
       .getMultipleAccounts(vaultReservesAddresses, { commitment: 'processed' })
       .send();
-
-    const deserializedReserves = reserveAccounts.value.map((reserve, i) => {
+    return reserveAccounts.value.map((reserve, i) => {
       if (reserve === null) {
         // maybe reuse old here
         throw new Error(`Reserve account ${vaultReservesAddresses[i]} was not found`);
@@ -2381,11 +2388,25 @@ export class KaminoVaultClient {
         state: reserveAccount,
       };
     });
+  }
 
+  /**
+   * 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[],
+    oracleAccounts?: AllOracleAccounts
+  ): Promise<Map<Address, KaminoReserve>> {
+    const vaultReservesAddressesSet = new Set<Address>(vaults.flatMap((vault) => this.getVaultReserves(vault)));
+    const vaultReservesAddresses = [...vaultReservesAddressesSet];
+    const deserializedReserves = await batchFetch(vaultReservesAddresses, (chunk) =>
+      this.loadReserializedReserves(chunk)
+    );
     const reservesAndOracles = await getTokenOracleData(this.getConnection(), deserializedReserves, oracleAccounts);
-
     const kaminoReserves = new Map<Address, KaminoReserve>();
-
     reservesAndOracles.forEach(([reserve, oracle], index) => {
       if (!oracle) {
         throw Error(
@@ -2849,7 +2870,7 @@ export class KaminoVaultClient {
   }
 
   /**
-   * This will return the APY of the vault under the assumption that all the available tokens in the vault are all the time invested in the reserves as ratio; for percentage it needs multiplication by 100
+   * This will return the APY of the vault under the assumption that all the available tokens in the vault are all the time invested in the reserves as requested by the weights; for percentage it needs multiplication by 100
    * @param vault - the kamino vault to get APY for
    * @param slot - 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