@kamino-finance/klend-sdk 7.2.2 → 7.2.4

package/src/classes/manager.ts

@@ -80,6 +80,7 @@ import { VaultConfigField, VaultConfigFieldKind } from '../@codegen/kvault/types
 import {
   AcceptVaultOwnershipIxs,
   APYs,
+  CreateVaultFarm,
   DepositIxs,
   DisinvestAllReservesIxs,
   InitVaultIxs,
@@ -238,6 +239,23 @@ export class KaminoManager {
     return this._vaultClient.createVaultIxs(vaultConfig);
   }
 
+  /**
+   * This method creates a farm for a vault
+   * @param admin - the admin of the vault
+   * @param vault - the vault to create a farm for (the vault should be already initialized)
+   * @returns a struct with the farm, the setup farm ixs and the update farm ixs
+   */
+  async createVaultFarmIxs(admin: TransactionSigner, vault: KaminoVault): Promise<CreateVaultFarm> {
+    const vaultState = await vault.getState();
+    if (!vaultState) {
+      throw new Error('Vault not initialized');
+    }
+    if (vaultState.vaultFarm !== DEFAULT_PUBLIC_KEY) {
+      throw new Error('Vault already has a farm');
+    }
+    return this._vaultClient.createVaultFarm(admin, vault.address, vaultState.sharesMint);
+  }
+
   /**
    * This method creates an instruction to set the shares metadata for a vault
    * @param authority - the vault admin
@@ -581,20 +599,24 @@ export class KaminoManager {
    * @param mode the field to update (based on VaultConfigFieldKind enum)
    * @param value the value to update the field with
    * @param [signer] 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 | string,
     value: string,
-    signer?: TransactionSigner
+    signer?: TransactionSigner,
+    lutIxsSigner?: TransactionSigner,
+    skipLutUpdate: boolean = false
   ): Promise<UpdateVaultConfigIxs> {
     if (typeof mode === 'string') {
       const field = VaultConfigField.fromDecoded({ [mode]: '' });
-      return this._vaultClient.updateVaultConfigIxs(vault, field, value, signer);
+      return this._vaultClient.updateVaultConfigIxs(vault, field, value, signer, lutIxsSigner, skipLutUpdate);
     }
 
-    return this._vaultClient.updateVaultConfigIxs(vault, mode, value, signer);
+    return this._vaultClient.updateVaultConfigIxs(vault, mode, value, signer, lutIxsSigner, skipLutUpdate);
   }
 
   /** Sets the farm where the shares can be staked. This is store in vault state and a vault can only have one farm, so the new farm will ovveride the old farm
@@ -607,9 +629,18 @@ export class KaminoManager {
     vault: KaminoVault,
     farm: Address,
     errorOnOverride: boolean = true,
-    vaultAdminAuthority?: TransactionSigner
+    vaultAdminAuthority?: TransactionSigner,
+    lutIxsSigner?: TransactionSigner,
+    skipLutUpdate: boolean = false
   ): Promise<UpdateVaultConfigIxs> {
-    return this._vaultClient.setVaultFarmIxs(vault, farm, errorOnOverride, vaultAdminAuthority);
+    return this._vaultClient.setVaultFarmIxs(
+      vault,
+      farm,
+      errorOnOverride,
+      vaultAdminAuthority,
+      lutIxsSigner,
+      skipLutUpdate
+    );
   }
 
   /**

package/src/classes/vault.ts

@@ -93,6 +93,7 @@ import { getAccountOwner, getProgramAccounts } from '../utils/rpc';
 import {
   AcceptVaultOwnershipIxs,
   APYs,
+  CreateVaultFarm,
   DepositIxs,
   DisinvestAllReservesIxs,
   InitVaultIxs,
@@ -107,9 +108,11 @@ import {
 } from './vault_types';
 import { batchFetch, collToLamportsDecimal, ZERO } from '@kamino-finance/kliquidity-sdk';
 import { FullBPSDecimal } from '@kamino-finance/kliquidity-sdk/dist/utils/CreationParameters';
-import { FarmIncentives, FarmState, getUserStatePDA } from '@kamino-finance/farms-sdk/dist';
+import { FarmConfigOption, FarmIncentives, FarmState, getUserStatePDA } from '@kamino-finance/farms-sdk/dist';
 import { getAccountsInLut, initLookupTableIx, insertIntoLookupTableIxs } from '../utils/lookupTable';
 import {
+  FARMS_ADMIN_MAINNET,
+  FARMS_GLOBAL_CONFIG_MAINNET,
   getFarmStakeIxs,
   getFarmUnstakeAndWithdrawIxs,
   getSharesInFarmUserPosition,
@@ -285,6 +288,8 @@ export class KaminoVaultClient {
     };
     const initVaultIx = initVault(initVaultAccounts, undefined, this._kaminoVaultProgramId);
 
+    const createVaultFarm = await this.createVaultFarm(vaultConfig.admin, vaultState.address, sharesMint);
+
     // create and set up the vault lookup table
     const [createLUTIx, lut] = await initLookupTableIx(vaultConfig.admin, slot);
 
@@ -300,6 +305,8 @@ export class KaminoVaultClient {
       TOKEN_PROGRAM_ADDRESS,
       this._kaminoLendProgramId,
       SYSVAR_INSTRUCTIONS_ADDRESS,
+      createVaultFarm.farm.address,
+      FARMS_GLOBAL_CONFIG_MAINNET,
     ];
     const insertIntoLUTIxs = await insertIntoLookupTableIxs(
       this.getConnection(),
@@ -345,6 +352,12 @@ export class KaminoVaultClient {
       );
       ixs.push(setNameIx);
     }
+    const setFarmIx = this.updateUninitialisedVaultConfigIx(
+      vaultConfig.admin,
+      vaultState.address,
+      new VaultConfigField.Farm(),
+      createVaultFarm.farm.address
+    );
 
     const metadataIx = await this.getSetSharesMetadataIx(
       this.getConnection(),
@@ -366,10 +379,57 @@ export class KaminoVaultClient {
         populateLUTIxs: insertIntoLUTIxs,
         cleanupIxs,
         initSharesMetadataIx: metadataIx,
+        createVaultFarm,
+        setFarmToVaultIx: setFarmIx,
       },
     };
   }
 
+  /**
+   * This method creates a farm for a vault
+   * @param signer - the signer of the transaction
+   * @param vaultSharesMint - the mint of the vault shares
+   * @param vaultAddress - the address of the vault (it doesn't need to be already initialized)
+   * @returns a struct with the farm, the setup farm ixs and the update farm ixs
+   */
+  async createVaultFarm(
+    signer: TransactionSigner,
+    vaultAddress: Address,
+    vaultSharesMint: Address
+  ): Promise<CreateVaultFarm> {
+    const farmsSDK = new Farms(this._rpc);
+
+    const farm = await generateKeyPairSigner();
+    const ixs = await farmsSDK.createFarmIxs(signer, farm, FARMS_GLOBAL_CONFIG_MAINNET, vaultSharesMint);
+
+    const updatePendingFarmAdminIx = await farmsSDK.updateFarmConfigIx(
+      signer,
+      farm.address,
+      DEFAULT_PUBLIC_KEY,
+      new FarmConfigOption.UpdatePendingFarmAdmin(),
+      FARMS_ADMIN_MAINNET,
+      undefined,
+      undefined,
+      true
+    );
+    const updateFarmVaultIdIx = await farmsSDK.updateFarmConfigIx(
+      signer,
+      farm.address,
+      DEFAULT_PUBLIC_KEY,
+      new FarmConfigOption.UpdateVaultId(),
+      vaultAddress,
+      undefined,
+      undefined,
+      true
+    );
+
+    return {
+      farm,
+      setupFarmIxs: ixs,
+      updateFarmIxs: [updatePendingFarmAdminIx, updateFarmVaultIdIx],
+    };
+  }
+
   /**
    * This method creates an instruction to set the shares metadata for a vault
    * @param rpc
@@ -697,13 +757,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 +817,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 +868,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
+    );
   }
 
   /**
@@ -1916,7 +1996,8 @@ export class KaminoVaultClient {
       holdings.totalAUMIncludingFees.sub(holdings.pendingFees),
       new Decimal(vaultState.unallocatedWeight.toString()),
       new Decimal(vaultState.unallocatedTokensCap.toString()),
-      initialVaultAllocations
+      initialVaultAllocations,
+      vaultState.tokenMintDecimals.toNumber()
     );
   }
 
@@ -1924,9 +2005,16 @@ export class KaminoVaultClient {
     vaultAUM: Decimal,
     vaultUnallocatedWeight: Decimal,
     vaultUnallocatedCap: Decimal,
-    initialVaultAllocations: Map<Address, ReserveAllocationOverview>
+    initialVaultAllocations: Map<Address, ReserveAllocationOverview>,
+    vaultTokenDecimals: number
   ) {
-    return computeReservesAllocation(vaultAUM, vaultUnallocatedWeight, vaultUnallocatedCap, initialVaultAllocations);
+    return computeReservesAllocation(
+      vaultAUM,
+      vaultUnallocatedWeight,
+      vaultUnallocatedCap,
+      initialVaultAllocations,
+      vaultTokenDecimals
+    );
   }
 
   /**
@@ -2018,9 +2106,7 @@ export class KaminoVaultClient {
       if (await vault.hasFarm()) {
         const userFarmState = allUserFarmStatesMap.get(state.vaultFarm);
         if (userFarmState) {
-          console.log('there is a farm state for vault', vault.address);
           const stakedShares = getSharesInFarmUserPosition(userFarmState, state.sharesMintDecimals.toNumber());
-          console.log('staked shares', stakedShares);
           const userSharesBalance = vaultUserShareBalance.get(vault.address);
           if (userSharesBalance) {
             userSharesBalance.stakedShares = stakedShares;

package/src/classes/vault_types.ts

@@ -1,4 +1,4 @@
-import { Address, Instruction } from '@solana/kit';
+import { Address, Instruction, TransactionSigner } from '@solana/kit';
 import Decimal from 'decimal.js/decimal';
 
 /** the populateLUTIxs should be executed in a separate transaction as we cannot create and populate a lookup table in the same tx */
@@ -9,6 +9,8 @@ export type InitVaultIxs = {
   populateLUTIxs: Instruction[];
   cleanupIxs: Instruction[];
   initSharesMetadataIx: Instruction;
+  createVaultFarm: CreateVaultFarm;
+  setFarmToVaultIx: Instruction;
 };
 
 export type AcceptVaultOwnershipIxs = {
@@ -78,3 +80,9 @@ export type APYs = {
   grossAPY: Decimal;
   netAPY: Decimal;
 };
+
+export type CreateVaultFarm = {
+  farm: TransactionSigner;
+  setupFarmIxs: Instruction[];
+  updateFarmIxs: Instruction[];
+};

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 : ''}`,
@@ -352,6 +352,22 @@ async function main() {
           ...instructions.createAtaIfNeededIxs,
           ...instructions.initVaultIxs,
           instructions.createLUTIx,
+          instructions.setFarmToVaultIx,
+          ...getPriorityFeeAndCuIxs({
+            priorityFeeMultiplier: 2500,
+          }),
+        ],
+        mode,
+        []
+      );
+      await sleep(2000);
+      // create the farm
+      await processTx(
+        env.c,
+        admin,
+        [
+          ...instructions.createVaultFarm.setupFarmIxs,
+          ...instructions.createVaultFarm.updateFarmIxs,
           ...getPriorityFeeAndCuIxs({
             priorityFeeMultiplier: 2500,
           }),
@@ -455,7 +471,9 @@ async function main() {
         kaminoVault,
         new PendingVaultAdmin(),
         newAdmin,
-        signer
+        signer,
+        undefined,
+        true
       );
 
       await processTx(
@@ -485,7 +503,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 +523,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 +612,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 +634,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 +680,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 +694,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 +722,7 @@ async function main() {
       for (const ix of syncLUTIxs.syncLUTIxs) {
         await processTx(
           env.c,
-          signer,
+          txSigner,
           [
             ix,
             ...getPriorityFeeAndCuIxs({
@@ -1353,6 +1398,7 @@ async function main() {
         console.log('reserve ', reserveAddress);
         console.log('reserve incentive', incentive);
       });
+      console.log('totalIncentivesAPY', vaultOverview.reservesFarmsIncentives.totalIncentivesAPY.toString());
     });
 
   commands

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

package/src/utils/vaultAllocation.ts

@@ -1,5 +1,6 @@
 import Decimal from 'decimal.js';
 import { Address } from '@solana/kit';
+import { lamportsToCollDecimal } from '@kamino-finance/farms-sdk';
 
 export interface ReserveAllocationOverview {
   targetWeight: Decimal;
@@ -13,21 +14,22 @@ export interface VaultAllocationResult {
 }
 
 const ZERO = new Decimal(0);
-const ONE = new Decimal(1);
 
 /**
  * Computes the allocation of vault funds across reserves based on weights and caps
- * @param vaultAUM - Total AUM of the vault
+ * @param vaultAUM - Total AUM of the vault, in tokens
  * @param vaultUnallocatedWeight - Weight for unallocated funds
  * @param vaultUnallocatedCap - Maximum amount that can remain unallocated
  * @param initialVaultAllocations - Map of reserve addresses to their allocation configurations
- * @returns Object containing target unallocated amount and target allocations per reserve
+ * @param vaultTokenDecimals - The number of decimals of the vault token, needed to compute the min amount
+ * @returns Object containing target unallocated amount and target allocations per reserve, in tokens
  */
 export function computeReservesAllocation(
   vaultAUM: Decimal,
   vaultUnallocatedWeight: Decimal,
   vaultUnallocatedCap: Decimal,
-  initialVaultAllocations: Map<Address, ReserveAllocationOverview>
+  initialVaultAllocations: Map<Address, ReserveAllocationOverview>,
+  vaultTokenDecimals: number
 ): VaultAllocationResult {
   let totalAllocation = new Decimal(0);
   const allReserves = Array.from(initialVaultAllocations.keys());
@@ -51,8 +53,10 @@ export function computeReservesAllocation(
 
   let currentAllocationSum = totalAllocation;
 
+  const reservesCount = allReserves.length;
+  const maxRemainedUninvestedLamports = lamportsToCollDecimal(new Decimal(reservesCount), vaultTokenDecimals); // invest only if the AUM has more lamports than the number of reserves
   // Iteratively allocate funds to reserves based on weights and caps
-  while (totalLeftToInvest.gt(ONE) && currentAllocationSum.gt(ZERO)) {
+  while (totalLeftToInvest.gt(maxRemainedUninvestedLamports) && currentAllocationSum.gt(ZERO)) {
     const totalLeftover = totalLeftToInvest;
 
     for (const reserve of allReserves) {