Origination fees on borrow (#239)

Adds per-bank configurable origination fee that is recorded on the bank upon any borrow. The fee is configurable by the group admin, and is split between the program (i.e. fee state wallet) and the group.

README.md

@@ -76,14 +76,12 @@ use an x86 toolchain when compiling and running the tests.
 
 ## Rust Tests
 
-Run the full test suite with `.scripts/test-program.sh <program_to_test>`
-
-- e.g. `.scripts/test-program.sh all --sane`
+Run the full test suite with `./scripts/test-program.sh <program_to_test>`
+* e.g. `./scripts/test-program.sh all --sane`
 
 Run a single test:
-`.scripts/test-program.sh <program_to_test> <name_of_test>`
-
-- e.g. `.scripts/test-program.sh marginfi configure_bank_success --verbose`
+`./scripts/test-program.sh <program_to_test> <name_of_test>`
+* e.g. `./scripts/test-program.sh marginfi configure_bank_success --verbose`
 
 ## Localnet Anchor Tests
 

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

@@ -257,6 +257,8 @@ pub enum BankCommand {
         pf_fa: Option<f64>,
         #[clap(long, help = "Protocol IR fee")]
         pf_ir: Option<f64>,
+        #[clap(long, help = "Protocol origination fee")]
+        pf_or: Option<f64>,
         #[clap(long, arg_enum, help = "Bank risk tier")]
         risk_tier: Option<RiskTierArg>,
         #[clap(long, arg_enum, help = "Bank oracle type")]
@@ -669,6 +671,7 @@ fn bank(subcmd: BankCommand, global_options: &GlobalOptions) -> Result<()> {
             if_ir,
             pf_fa,
             pf_ir,
+            pf_or,
             risk_tier,
             oracle_type,
             oracle_key,
@@ -718,6 +721,7 @@ fn bank(subcmd: BankCommand, global_options: &GlobalOptions) -> Result<()> {
                         insurance_ir_fee: if_ir.map(|x| I80F48::from_num(x).into()),
                         protocol_fixed_fee_apr: pf_fa.map(|x| I80F48::from_num(x).into()),
                         protocol_ir_fee: pf_ir.map(|x| I80F48::from_num(x).into()),
+                        protocol_origination_fee: pf_or.map(|x| I80F48::from_num(x).into()),
                     }),
                     risk_tier: risk_tier.map(|x| x.into()),
                     total_asset_value_init_limit: usd_init_limit,

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

@@ -2,6 +2,7 @@ use crate::{
     bank_signer, check,
     constants::{LIQUIDITY_VAULT_AUTHORITY_SEED, LIQUIDITY_VAULT_SEED},
     events::{AccountEventHeader, LendingAccountBorrowEvent},
+    math_error,
     prelude::{MarginfiError, MarginfiGroup, MarginfiResult},
     state::{
         marginfi_account::{BankAccountWrapper, MarginfiAccount, RiskEngine, DISABLED_FLAG},
@@ -43,6 +44,8 @@ pub fn lending_account_borrow<'info>(
     )?;
 
     let mut marginfi_account = marginfi_account_loader.load_mut()?;
+    let group = &marginfi_group_loader.load()?;
+    let program_fee_rate: I80F48 = group.fee_state_cache.program_fee_rate.into();
 
     check!(
         !marginfi_account.get_flag(DISABLED_FLAG),
@@ -51,15 +54,21 @@ pub fn lending_account_borrow<'info>(
 
     bank_loader.load_mut()?.accrue_interest(
         clock.unix_timestamp,
-        &*marginfi_group_loader.load()?,
+        group,
         #[cfg(not(feature = "client"))]
         bank_loader.key(),
     )?;
 
+    let mut origination_fee: I80F48 = I80F48::ZERO;
     {
         let mut bank = bank_loader.load_mut()?;
 
         let liquidity_vault_authority_bump = bank.liquidity_vault_authority_bump;
+        let origination_fee_rate: I80F48 = bank
+            .config
+            .interest_rate_config
+            .protocol_origination_fee
+            .into();
 
         let mut bank_account = BankAccountWrapper::find_or_create(
             &bank_loader.key(),
@@ -80,7 +89,21 @@ pub fn lending_account_borrow<'info>(
             .transpose()?
             .unwrap_or(amount);
 
-        bank_account.borrow(I80F48::from_num(amount_pre_fee))?;
+        let origination_fee_u64: u64;
+        if !origination_fee_rate.is_zero() {
+            origination_fee = I80F48::from_num(amount_pre_fee)
+                .checked_mul(origination_fee_rate)
+                .ok_or_else(math_error!())?;
+            origination_fee_u64 = origination_fee.checked_to_num().ok_or_else(math_error!())?;
+
+            // Incurs a borrow that includes the origination fee (but withdraws just the amt)
+            bank_account.borrow(I80F48::from_num(amount_pre_fee) + origination_fee)?;
+        } else {
+            // Incurs a borrow for the amount without any fee
+            origination_fee_u64 = 0;
+            bank_account.borrow(I80F48::from_num(amount_pre_fee))?;
+        }
+
         bank_account.withdraw_spl_transfer(
             amount_pre_fee,
             bank_liquidity_vault.to_account_info(),
@@ -105,8 +128,39 @@ pub fn lending_account_borrow<'info>(
             },
             bank: bank_loader.key(),
             mint: bank.mint,
-            amount: amount_pre_fee,
+            amount: amount_pre_fee + origination_fee_u64,
         });
+    } // release mutable borrow of bank
+
+    // The program and/or group fee account gains the origination fee
+    {
+        let mut bank = bank_loader.load_mut()?;
+
+        if !origination_fee.is_zero() {
+            let mut bank_fees_after: I80F48 = bank.collected_group_fees_outstanding.into();
+
+            if !program_fee_rate.is_zero() {
+                // Some portion of the origination fee to goes to program fees
+                let program_fee_amount: I80F48 = origination_fee
+                    .checked_mul(program_fee_rate)
+                    .ok_or_else(math_error!())?;
+                // The remainder of the origination fee goes to group fees
+                bank_fees_after = bank_fees_after
+                    .saturating_add(origination_fee.saturating_sub(program_fee_amount));
+
+                // Update the bank's program fees
+                let program_fees_before: I80F48 = bank.collected_program_fees_outstanding.into();
+                bank.collected_program_fees_outstanding = program_fees_before
+                    .saturating_add(program_fee_amount)
+                    .into();
+            } else {
+                // If program fee rate is zero, add the full origination fee to group fees
+                bank_fees_after = bank_fees_after.saturating_add(origination_fee);
+            }
+
+            // Update the bank's group fees
+            bank.collected_group_fees_outstanding = bank_fees_after.into();
+        }
     }
 
     // Check account health, if below threshold fail transaction

programs/marginfi/src/state/marginfi_group.rs

@@ -151,29 +151,22 @@ pub struct InterestRateConfigCompact {
     pub insurance_ir_fee: WrappedI80F48,
     pub protocol_fixed_fee_apr: WrappedI80F48,
     pub protocol_ir_fee: WrappedI80F48,
+    pub protocol_origination_fee: WrappedI80F48,
 }
 
 impl From<InterestRateConfigCompact> for InterestRateConfig {
-    fn from(
-        InterestRateConfigCompact {
-            optimal_utilization_rate,
-            plateau_interest_rate,
-            max_interest_rate,
-            insurance_fee_fixed_apr,
-            insurance_ir_fee,
-            protocol_fixed_fee_apr,
-            protocol_ir_fee,
-        }: InterestRateConfigCompact,
-    ) -> Self {
-        Self {
-            optimal_utilization_rate,
-            plateau_interest_rate,
-            max_interest_rate,
-            insurance_fee_fixed_apr,
-            insurance_ir_fee,
-            protocol_fixed_fee_apr,
-            protocol_ir_fee,
-            _padding: [0; 32],
+    fn from(ir_config: InterestRateConfigCompact) -> Self {
+        InterestRateConfig {
+            optimal_utilization_rate: ir_config.optimal_utilization_rate,
+            plateau_interest_rate: ir_config.plateau_interest_rate,
+            max_interest_rate: ir_config.max_interest_rate,
+            insurance_fee_fixed_apr: ir_config.insurance_fee_fixed_apr,
+            insurance_ir_fee: ir_config.insurance_ir_fee,
+            protocol_fixed_fee_apr: ir_config.protocol_fixed_fee_apr,
+            protocol_ir_fee: ir_config.protocol_ir_fee,
+            protocol_origination_fee: ir_config.protocol_origination_fee,
+            _padding0: [0; 16],
+            _padding1: [[0; 32]; 3],
         }
     }
 }
@@ -188,6 +181,7 @@ impl From<InterestRateConfig> for InterestRateConfigCompact {
             insurance_ir_fee: ir_config.insurance_ir_fee,
             protocol_fixed_fee_apr: ir_config.protocol_fixed_fee_apr,
             protocol_ir_fee: ir_config.protocol_ir_fee,
+            protocol_origination_fee: ir_config.protocol_origination_fee,
         }
     }
 }
@@ -215,8 +209,10 @@ pub struct InterestRateConfig {
     pub protocol_fixed_fee_apr: WrappedI80F48,
     /// Earned by the group, goes to `collected_group_fees_outstanding`
     pub protocol_ir_fee: WrappedI80F48,
+    pub protocol_origination_fee: WrappedI80F48,
 
-    pub _padding: [u32; 32],
+    pub _padding0: [u8; 16],
+    pub _padding1: [[u8; 32]; 3],
 }
 
 impl InterestRateConfig {
@@ -418,6 +414,7 @@ pub struct InterestRateConfigOpt {
     pub insurance_ir_fee: Option<WrappedI80F48>,
     pub protocol_fixed_fee_apr: Option<WrappedI80F48>,
     pub protocol_ir_fee: Option<WrappedI80F48>,
+    pub protocol_origination_fee: Option<WrappedI80F48>,
 }
 
 /// Group level configuration to be used in bank accounts.

programs/marginfi/tests/admin_actions/bankruptcy.rs

@@ -285,6 +285,7 @@ async fn marginfi_group_handle_bankruptcy_success(
 #[test_case(10_000., BankMint::PyUSD, BankMint::SolSwb)]
 #[test_case(10_000., BankMint::PyUSD, BankMint::T22WithFee)]
 #[test_case(10_000., BankMint::T22WithFee, BankMint::Sol)]
+#[test_case(10_000., BankMint::Usdc, BankMint::SolSwbOrigFee)] // Sol @ ~ $153
 #[tokio::test]
 async fn marginfi_group_handle_bankruptcy_success_fully_insured(
     borrow_amount: f64,
@@ -447,7 +448,18 @@ async fn marginfi_group_handle_bankruptcy_success_fully_insured(
         test_f.get_bank(&debt_mint).mint.mint.decimals,
         f64
     );
+    let origination_fee_rate: I80F48 = debt_bank
+        .config
+        .interest_rate_config
+        .protocol_origination_fee
+        .into();
+    let origination_fee: I80F48 = I80F48::from_num(borrow_amount_native)
+        .checked_mul(origination_fee_rate)
+        .unwrap()
+        .ceil(); // Round up when repaying
+    let origination_fee_u64: u64 = origination_fee.checked_to_num().expect("out of bounds");
     let actual_borrow_position = borrow_amount_native
+        + origination_fee_u64
         + debt_bank_mint_state
             .get_extension::<TransferFeeConfig>()
             .map(|tf| {
@@ -466,6 +478,7 @@ async fn marginfi_group_handle_bankruptcy_success_fully_insured(
                 })
                 .unwrap_or(0),
     );
+
     let expected_liquidity_vault_delta = I80F48::from(actual_borrow_position);
 
     let actual_liquidity_vault_delta = post_liquidity_vault_balance - pre_liquidity_vault_balance;

programs/marginfi/tests/admin_actions/setup_bank.rs

@@ -319,6 +319,7 @@ async fn configure_bank_success(bank_mint: BankMint) -> anyhow::Result<()> {
             insurance_ir_fee: Some(I80F48::from_num(0.11).into()),
             protocol_fixed_fee_apr: Some(I80F48::from_num(0.51).into()),
             protocol_ir_fee: Some(I80F48::from_num(0.011).into()),
+            protocol_origination_fee: Some(I80F48::ZERO.into()),
         }),
         ..BankConfigOpt::default()
     };

programs/marginfi/tests/user_actions/borrow.rs

@@ -19,6 +19,7 @@ use test_case::test_case;
 #[test_case(128932.0, 9834.0, BankMint::PyUSD, BankMint::SolSwb)]
 #[test_case(240., 0.092, BankMint::PyUSD, BankMint::T22WithFee)]
 #[test_case(36., 1.7, BankMint::T22WithFee, BankMint::Sol)]
+#[test_case(200., 1.1, BankMint::Usdc, BankMint::SolSwbOrigFee)] // Sol @ ~ $153
 #[tokio::test]
 async fn marginfi_account_borrow_success(
     deposit_amount: f64,
@@ -78,13 +79,16 @@ async fn marginfi_account_borrow_success(
     // -------------------------------------------------------------------------
 
     let debt_bank_f = test_f.get_bank(&debt_mint);
+    let bank_before = debt_bank_f.load().await;
 
     let pre_vault_balance = debt_bank_f
         .get_vault_token_account(BankVaultType::Liquidity)
         .await
         .balance()
         .await;
     let pre_user_debt_accounted = I80F48::ZERO;
+    let pre_fee_group_fees: I80F48 = bank_before.collected_group_fees_outstanding.into();
+    let pre_fee_program_fees: I80F48 = bank_before.collected_program_fees_outstanding.into();
 
     let res = user_mfi_account_f
         .try_bank_borrow(user_debt_token_account_f.key, debt_bank_f, borrow_amount)
@@ -101,9 +105,7 @@ async fn marginfi_account_borrow_success(
         .lending_account
         .get_balance(&debt_bank_f.key)
         .unwrap();
-    let post_user_debt_accounted = debt_bank_f
-        .load()
-        .await
+    let post_user_debt_accounted = bank_before
         .get_asset_amount(balance.liability_shares.into())
         .unwrap();
 
@@ -119,6 +121,23 @@ async fn marginfi_account_borrow_success(
         })
         .unwrap_or(0);
     let borrow_amount_pre_fee = borrow_amount_native + borrow_fee;
+    let origination_fee_rate: I80F48 = bank_before
+        .config
+        .interest_rate_config
+        .protocol_origination_fee
+        .into();
+    let program_fee_rate: I80F48 = test_f
+        .marginfi_group
+        .load()
+        .await
+        .fee_state_cache
+        .program_fee_rate
+        .into();
+    let origination_fee: I80F48 = I80F48::from_num(borrow_amount_native)
+        .checked_mul(origination_fee_rate)
+        .unwrap();
+    let program_origination_fee: I80F48 = origination_fee.checked_mul(program_fee_rate).unwrap();
+    let group_origination_fee: I80F48 = origination_fee.saturating_sub(program_origination_fee);
 
     let active_balance_count = marginfi_account
         .lending_account
@@ -130,13 +149,30 @@ async fn marginfi_account_borrow_success(
     let actual_liquidity_vault_delta = post_vault_balance as i64 - pre_vault_balance as i64;
     let accounted_user_balance_delta = post_user_debt_accounted - pre_user_debt_accounted;
 
+    // The liquidity vault paid out just the pre-origination fee amount (e.g. what the user borrowed
+    // before accounting for the fee)
     assert_eq!(expected_liquidity_vault_delta, actual_liquidity_vault_delta);
     assert_eq_with_tolerance!(
-        I80F48::from(expected_liquidity_vault_delta),
+        // Note: the user still gains debt which includes the origination fee
+        I80F48::from(expected_liquidity_vault_delta) - origination_fee,
         -accounted_user_balance_delta,
         1
     );
 
+    // The outstanding origination fee is recorded
+    let bank_after = debt_bank_f.load().await;
+    let post_fee_program_fees: I80F48 = bank_after.collected_program_fees_outstanding.into();
+    assert_eq!(
+        pre_fee_program_fees + program_origination_fee,
+        post_fee_program_fees
+    );
+
+    let post_fee_group_fees: I80F48 = bank_after.collected_group_fees_outstanding.into();
+    assert_eq!(
+        pre_fee_group_fees + group_origination_fee,
+        post_fee_group_fees
+    );
+
     Ok(())
 }
 
@@ -147,7 +183,7 @@ async fn marginfi_account_borrow_success(
 #[test_case(128_932., 10_000., 15_000.0, BankMint::PyUSD, BankMint::SolSwb)]
 #[test_case(240., 0.092, 500., BankMint::PyUSD, BankMint::T22WithFee)]
 #[test_case(36., 1.7, 1.9, BankMint::T22WithFee, BankMint::Sol)]
-#[test_case(1., 100., 155.1, BankMint::SolSwbPull, BankMint::Usdc)] // Sol @ $155
+#[test_case(1., 100., 155.1, BankMint::SolSwbPull, BankMint::Usdc)] // Sol @ ~ $153
 #[tokio::test]
 async fn marginfi_account_borrow_failure_not_enough_collateral(
     deposit_amount: f64,