Add deposit up to limit functionality

clients/rust/marginfi-cli/src/entrypoint.rs

@@ -429,6 +429,7 @@ pub enum AccountCommand {
     Deposit {
         bank: Pubkey,
         ui_amount: f64,
+        deposit_up_to_limit: Option<bool>,
     },
     Withdraw {
         bank: Pubkey,
@@ -953,9 +954,17 @@ fn process_account_subcmd(subcmd: AccountCommand, global_options: &GlobalOptions
         AccountCommand::Get { account } => {
             processor::marginfi_account_get(profile, &config, account)
         }
-        AccountCommand::Deposit { bank, ui_amount } => {
-            processor::marginfi_account_deposit(&profile, &config, bank, ui_amount)
-        }
+        AccountCommand::Deposit {
+            bank,
+            ui_amount,
+            deposit_up_to_limit,
+        } => processor::marginfi_account_deposit(
+            &profile,
+            &config,
+            bank,
+            ui_amount,
+            deposit_up_to_limit,
+        ),
         AccountCommand::Withdraw {
             bank,
             ui_amount,

clients/rust/marginfi-cli/src/processor/mod.rs

@@ -2057,6 +2057,7 @@ pub fn marginfi_account_deposit(
     config: &Config,
     bank_pk: Pubkey,
     ui_amount: f64,
+    deposit_up_to_limit: Option<bool>,
 ) -> Result<()> {
     let rpc_client = config.mfi_program.rpc();
     let signer = config.get_non_ms_authority_keypair()?;
@@ -2094,7 +2095,11 @@ pub fn marginfi_account_deposit(
             token_program,
         }
         .to_account_metas(Some(true)),
-        data: marginfi::instruction::LendingAccountDeposit { amount }.data(),
+        data: marginfi::instruction::LendingAccountDeposit {
+            amount,
+            deposit_up_to_limit,
+        }
+        .data(),
     };
     if token_program == spl_token_2022::ID {
         ix.accounts

programs/liquidity-incentive-program/src/instructions/create_deposit.rs

@@ -100,7 +100,7 @@ pub fn process<'info>(
         return Err(ProgramError::InvalidAccountData.into());
     }
 
-    marginfi::cpi::lending_account_deposit(cpi_ctx, amount)?;
+    marginfi::cpi::lending_account_deposit(cpi_ctx, amount, None)?;
 
     close_account(CpiContext::new_with_signer(
         ctx.accounts.token_program.to_account_info(),

programs/liquidity-incentive-program/tests/lip.rs

@@ -150,7 +150,7 @@ async fn campaign_mixed_yield() -> Result<()> {
     let sol_funding_account = test_f.sol_mint.create_token_account_and_mint_to(1000).await;
 
     borrower
-        .try_bank_deposit(sol_funding_account.key, &sol_bank, 1000)
+        .try_bank_deposit(sol_funding_account.key, &sol_bank, 1000, None)
         .await?;
 
     let usdc_borrowing_account = test_f
@@ -243,7 +243,7 @@ async fn campaign_max_yield() -> Result<()> {
     let sol_funding_account = test_f.sol_mint.create_token_account_and_mint_to(1000).await;
 
     borrower
-        .try_bank_deposit(sol_funding_account.key, &sol_bank, 1000)
+        .try_bank_deposit(sol_funding_account.key, &sol_bank, 1000, None)
         .await?;
 
     let usdc_borrowing_account = test_f

programs/marginfi/fuzz/fuzz_targets/lend.rs

@@ -19,6 +19,7 @@ enum Action {
         account: AccountIdx,
         bank: BankIdx,
         asset_amount: AssetAmount,
+        deposit_up_to_limit: bool,
     },
     Borrow {
         account: AccountIdx,
@@ -199,7 +200,8 @@ fn process_action<'bump>(action: &Action, mga: &'bump MarginfiFuzzContext<'bump>
             account,
             bank,
             asset_amount,
-        } => mga.process_action_deposit(account, bank, asset_amount)?,
+            deposit_up_to_limit,
+        } => mga.process_action_deposit(account, bank, asset_amount, Some(*deposit_up_to_limit))?,
         Action::Withdraw {
             account,
             bank,

programs/marginfi/fuzz/src/lib.rs

@@ -135,6 +135,7 @@ impl<'state> MarginfiFuzzContext<'state> {
                             * 10_u64
                                 .pow(marginfi_state.banks[bank_idx as usize].mint_decimals.into()),
                     ),
+                    None,
                 )
                 .unwrap();
         }
@@ -373,6 +374,7 @@ impl<'state> MarginfiFuzzContext<'state> {
         account_idx: &AccountIdx,
         bank_idx: &BankIdx,
         asset_amount: &AssetAmount,
+        deposit_up_to_limit: Option<bool>,
     ) -> anyhow::Result<()> {
         let marginfi_account = &self.marginfi_accounts[account_idx.0 as usize];
         sort_balances(airls(&marginfi_account.margin_account));
@@ -411,6 +413,7 @@ impl<'state> MarginfiFuzzContext<'state> {
                 Default::default(),
             ),
             asset_amount.0,
+            deposit_up_to_limit,
         );
 
         let success = if res.is_err() {
@@ -1031,7 +1034,7 @@ mod tests {
 
         assert_eq!(al.load().unwrap().admin, a.owner.key());
 
-        a.process_action_deposit(&AccountIdx(0), &BankIdx(0), &AssetAmount(1000))
+        a.process_action_deposit(&AccountIdx(0), &BankIdx(0), &AssetAmount(1000), None)
             .unwrap();
 
         let marginfi_account_ai = AccountLoader::<MarginfiAccount>::try_from_unchecked(
@@ -1052,9 +1055,9 @@ mod tests {
         let account_state = AccountsState::new();
         let a = MarginfiFuzzContext::setup(&account_state, &[BankAndOracleConfig::dummy(); 2], 2);
 
-        a.process_action_deposit(&AccountIdx(1), &BankIdx(1), &AssetAmount(1000))
+        a.process_action_deposit(&AccountIdx(1), &BankIdx(1), &AssetAmount(1000), None)
             .unwrap();
-        a.process_action_deposit(&AccountIdx(0), &BankIdx(0), &AssetAmount(1000))
+        a.process_action_deposit(&AccountIdx(0), &BankIdx(0), &AssetAmount(1000), None)
             .unwrap();
         a.process_action_borrow(&AccountIdx(0), &BankIdx(1), &AssetAmount(100))
             .unwrap();
@@ -1094,9 +1097,9 @@ mod tests {
         let account_state = AccountsState::new();
         let a = MarginfiFuzzContext::setup(&account_state, &[BankAndOracleConfig::dummy(); 2], 3);
 
-        a.process_action_deposit(&AccountIdx(1), &BankIdx(1), &AssetAmount(1000))
+        a.process_action_deposit(&AccountIdx(1), &BankIdx(1), &AssetAmount(1000), None)
             .unwrap();
-        a.process_action_deposit(&AccountIdx(0), &BankIdx(0), &AssetAmount(1000))
+        a.process_action_deposit(&AccountIdx(0), &BankIdx(0), &AssetAmount(1000), None)
             .unwrap();
         a.process_action_borrow(&AccountIdx(0), &BankIdx(1), &AssetAmount(500))
             .unwrap();
@@ -1132,7 +1135,7 @@ mod tests {
             println!("Health {health}");
         }
 
-        a.process_action_deposit(&AccountIdx(2), &BankIdx(1), &AssetAmount(1000))
+        a.process_action_deposit(&AccountIdx(2), &BankIdx(1), &AssetAmount(1000), None)
             .unwrap();
 
         a.process_liquidate_account(&AccountIdx(2), &AccountIdx(0), &AssetAmount(50))
@@ -1158,9 +1161,9 @@ mod tests {
 
         let a = MarginfiFuzzContext::setup(&account_state, &[BankAndOracleConfig::dummy(); 2], 3);
 
-        a.process_action_deposit(&AccountIdx(1), &BankIdx(1), &AssetAmount(1000))
+        a.process_action_deposit(&AccountIdx(1), &BankIdx(1), &AssetAmount(1000), None)
             .unwrap();
-        a.process_action_deposit(&AccountIdx(0), &BankIdx(0), &AssetAmount(1000))
+        a.process_action_deposit(&AccountIdx(0), &BankIdx(0), &AssetAmount(1000), None)
             .unwrap();
         a.process_action_borrow(&AccountIdx(0), &BankIdx(1), &AssetAmount(500))
             .unwrap();
@@ -1192,7 +1195,7 @@ mod tests {
             println!("Health {health}");
         }
 
-        a.process_action_deposit(&AccountIdx(2), &BankIdx(1), &AssetAmount(1000))
+        a.process_action_deposit(&AccountIdx(2), &BankIdx(1), &AssetAmount(1000), None)
             .unwrap();
 
         a.process_liquidate_account(&AccountIdx(2), &AccountIdx(0), &AssetAmount(1000))

programs/marginfi/src/instructions/marginfi_account/deposit.rs

@@ -2,6 +2,7 @@ use crate::{
     check,
     constants::LIQUIDITY_VAULT_SEED,
     events::{AccountEventHeader, LendingAccountDepositEvent},
+    math_error,
     prelude::*,
     state::{
         marginfi_account::{BankAccountWrapper, MarginfiAccount, DISABLED_FLAG},
@@ -24,6 +25,7 @@ use solana_program::sysvar::Sysvar;
 pub fn lending_account_deposit<'info>(
     mut ctx: Context<'_, '_, 'info, 'info, LendingAccountDeposit<'info>>,
     amount: u64,
+    deposit_up_to_limit: Option<bool>,
 ) -> MarginfiResult {
     let LendingAccountDeposit {
         marginfi_account: marginfi_account_loader,
@@ -41,6 +43,7 @@ pub fn lending_account_deposit<'info>(
         &*bank_loader.load()?,
         token_program.key,
     )?;
+    let deposit_up_to_limit = deposit_up_to_limit.unwrap_or(false);
 
     let mut bank = bank_loader.load_mut()?;
     let mut marginfi_account = marginfi_account_loader.load_mut()?;
@@ -52,6 +55,33 @@ pub fn lending_account_deposit<'info>(
         MarginfiError::AccountDisabled
     );
 
+    let deposit_amount = if deposit_up_to_limit && bank.config.is_deposit_limit_active() {
+        let current_asset_amount = bank.get_asset_amount(bank.total_asset_shares.into())?;
+        let deposit_limit = I80F48::from_num(bank.config.deposit_limit);
+
+        if current_asset_amount >= deposit_limit {
+            0
+        } else {
+            let remaining_capacity = deposit_limit
+                .checked_sub(current_asset_amount)
+                .ok_or_else(math_error!())?
+                .checked_sub(I80F48::ONE) // Subtract 1 to ensure we stay under limit: total_deposits_amount < deposit_limit
+                .ok_or_else(math_error!())?
+                .checked_floor()
+                .ok_or_else(math_error!())?
+                .checked_to_num::<u64>()
+                .ok_or_else(math_error!())?;
+
+            std::cmp::min(amount, remaining_capacity)
+        }
+    } else {
+        amount
+    };
+
+    if deposit_amount == 0 {
+        return Ok(());
+    }
+
     bank.accrue_interest(
         clock.unix_timestamp,
         &*marginfi_group_loader.load()?,
@@ -65,15 +95,19 @@ pub fn lending_account_deposit<'info>(
         &mut marginfi_account.lending_account,
     )?;
 
-    bank_account.deposit(I80F48::from_num(amount))?;
+    bank_account.deposit(I80F48::from_num(deposit_amount))?;
 
     let amount_pre_fee = maybe_bank_mint
         .as_ref()
         .map(|mint| {
-            utils::calculate_pre_fee_spl_deposit_amount(mint.to_account_info(), amount, clock.epoch)
+            utils::calculate_pre_fee_spl_deposit_amount(
+                mint.to_account_info(),
+                deposit_amount,
+                clock.epoch,
+            )
         })
         .transpose()?
-        .unwrap_or(amount);
+        .unwrap_or(deposit_amount);
 
     bank_account.deposit_spl_transfer(
         amount_pre_fee,
@@ -94,7 +128,7 @@ pub fn lending_account_deposit<'info>(
         },
         bank: bank_loader.key(),
         mint: bank.mint,
-        amount,
+        amount: deposit_amount,
     });
 
     Ok(())

programs/marginfi/src/lib.rs

@@ -112,8 +112,9 @@ pub mod marginfi {
     pub fn lending_account_deposit<'info>(
         ctx: Context<'_, '_, 'info, 'info, LendingAccountDeposit<'info>>,
         amount: u64,
+        deposit_up_to_limit: Option<bool>,
     ) -> MarginfiResult {
-        marginfi_account::lending_account_deposit(ctx, amount)
+        marginfi_account::lending_account_deposit(ctx, amount, deposit_up_to_limit)
     }
 
     pub fn lending_account_repay<'info>(