lending: Add instruction for changing reserve configuration after initialization (#3349)

* lending: Add instruction for configuring reserve params

* lending: (fix) remove duplicate import in modify_reserve_config test

* modify_reserve_config: refactor pack and unpack of ReserveConfig into helper func; refactor validate_reserve_config as method; refine tests

Author: throwbackjams

token-lending/program/src/instruction.rs

@@ -308,6 +308,19 @@ pub enum LendingInstruction {
         /// The amount that is to be borrowed - u64::MAX for up to 100% of available liquidity
         amount: u64,
     },
+
+    // 14
+    /// Modify the ReserveConfig parameters of an already initialized Reserve account
+    ///
+    /// Accounts expected by this instruction:
+    ///
+    ///   0. `[writable]` Reserve account
+    ///   1. `[]` Lending market account
+    ///   2. `[signer]` Lending market owner
+    ModifyReserveConfig {
+        /// Reserve configuration updated values
+        new_config: ReserveConfig,
+    },
 }
 
 impl LendingInstruction {
@@ -331,32 +344,10 @@ impl LendingInstruction {
             }
             2 => {
                 let (liquidity_amount, rest) = Self::unpack_u64(rest)?;
-                let (optimal_utilization_rate, rest) = Self::unpack_u8(rest)?;
-                let (loan_to_value_ratio, rest) = Self::unpack_u8(rest)?;
-                let (liquidation_bonus, rest) = Self::unpack_u8(rest)?;
-                let (liquidation_threshold, rest) = Self::unpack_u8(rest)?;
-                let (min_borrow_rate, rest) = Self::unpack_u8(rest)?;
-                let (optimal_borrow_rate, rest) = Self::unpack_u8(rest)?;
-                let (max_borrow_rate, rest) = Self::unpack_u8(rest)?;
-                let (borrow_fee_wad, rest) = Self::unpack_u64(rest)?;
-                let (flash_loan_fee_wad, rest) = Self::unpack_u64(rest)?;
-                let (host_fee_percentage, _rest) = Self::unpack_u8(rest)?;
+                let config = Self::unpack_reserve_config(rest)?;
                 Self::InitReserve {
                     liquidity_amount,
-                    config: ReserveConfig {
-                        optimal_utilization_rate,
-                        loan_to_value_ratio,
-                        liquidation_bonus,
-                        liquidation_threshold,
-                        min_borrow_rate,
-                        optimal_borrow_rate,
-                        max_borrow_rate,
-                        fees: ReserveFees {
-                            borrow_fee_wad,
-                            flash_loan_fee_wad,
-                            host_fee_percentage,
-                        },
-                    },
+                    config,
                 }
             }
             3 => Self::RefreshReserve,
@@ -394,6 +385,10 @@ impl LendingInstruction {
                 let (amount, _rest) = Self::unpack_u64(rest)?;
                 Self::FlashLoan { amount }
             }
+            14 => {
+                let new_config = Self::unpack_reserve_config(rest)?;
+                Self::ModifyReserveConfig { new_config }
+            }
             _ => {
                 msg!("Instruction cannot be unpacked");
                 return Err(LendingError::InstructionUnpackError.into());
@@ -453,6 +448,34 @@ impl LendingInstruction {
         Ok((pk, rest))
     }
 
+    fn unpack_reserve_config(input: &[u8]) -> Result<ReserveConfig, ProgramError> {
+        let (optimal_utilization_rate, rest) = Self::unpack_u8(input)?;
+        let (loan_to_value_ratio, rest) = Self::unpack_u8(rest)?;
+        let (liquidation_bonus, rest) = Self::unpack_u8(rest)?;
+        let (liquidation_threshold, rest) = Self::unpack_u8(rest)?;
+        let (min_borrow_rate, rest) = Self::unpack_u8(rest)?;
+        let (optimal_borrow_rate, rest) = Self::unpack_u8(rest)?;
+        let (max_borrow_rate, rest) = Self::unpack_u8(rest)?;
+        let (borrow_fee_wad, rest) = Self::unpack_u64(rest)?;
+        let (flash_loan_fee_wad, rest) = Self::unpack_u64(rest)?;
+        let (host_fee_percentage, _rest) = Self::unpack_u8(rest)?;
+
+        Ok(ReserveConfig {
+            optimal_utilization_rate,
+            loan_to_value_ratio,
+            liquidation_bonus,
+            liquidation_threshold,
+            min_borrow_rate,
+            optimal_borrow_rate,
+            max_borrow_rate,
+            fees: ReserveFees {
+                borrow_fee_wad,
+                flash_loan_fee_wad,
+                host_fee_percentage,
+            },
+        })
+    }
+
     /// Packs a [LendingInstruction](enum.LendingInstruction.html) into a byte buffer.
     pub fn pack(&self) -> Vec<u8> {
         let mut buf = Vec::with_capacity(size_of::<Self>());
@@ -471,35 +494,11 @@ impl LendingInstruction {
             }
             Self::InitReserve {
                 liquidity_amount,
-                config:
-                    ReserveConfig {
-                        optimal_utilization_rate,
-                        loan_to_value_ratio,
-                        liquidation_bonus,
-                        liquidation_threshold,
-                        min_borrow_rate,
-                        optimal_borrow_rate,
-                        max_borrow_rate,
-                        fees:
-                            ReserveFees {
-                                borrow_fee_wad,
-                                flash_loan_fee_wad,
-                                host_fee_percentage,
-                            },
-                    },
+                config,
             } => {
                 buf.push(2);
                 buf.extend_from_slice(&liquidity_amount.to_le_bytes());
-                buf.extend_from_slice(&optimal_utilization_rate.to_le_bytes());
-                buf.extend_from_slice(&loan_to_value_ratio.to_le_bytes());
-                buf.extend_from_slice(&liquidation_bonus.to_le_bytes());
-                buf.extend_from_slice(&liquidation_threshold.to_le_bytes());
-                buf.extend_from_slice(&min_borrow_rate.to_le_bytes());
-                buf.extend_from_slice(&optimal_borrow_rate.to_le_bytes());
-                buf.extend_from_slice(&max_borrow_rate.to_le_bytes());
-                buf.extend_from_slice(&borrow_fee_wad.to_le_bytes());
-                buf.extend_from_slice(&flash_loan_fee_wad.to_le_bytes());
-                buf.extend_from_slice(&host_fee_percentage.to_le_bytes());
+                Self::extend_buffer_from_reserve_config(&mut buf, &config);
             }
             Self::RefreshReserve => {
                 buf.push(3);
@@ -542,9 +541,27 @@ impl LendingInstruction {
                 buf.push(13);
                 buf.extend_from_slice(&amount.to_le_bytes());
             }
+            Self::ModifyReserveConfig { new_config } => {
+                buf.push(14);
+                Self::extend_buffer_from_reserve_config(&mut buf, &new_config);
+            }
         }
         buf
     }
+
+    // Helper function to pack a ReserveConfig into a Vec<u8> buffer
+    fn extend_buffer_from_reserve_config(buf: &mut Vec<u8>, config: &ReserveConfig) {
+        buf.extend_from_slice(&config.optimal_utilization_rate.to_le_bytes());
+        buf.extend_from_slice(&config.loan_to_value_ratio.to_le_bytes());
+        buf.extend_from_slice(&config.liquidation_bonus.to_le_bytes());
+        buf.extend_from_slice(&config.liquidation_threshold.to_le_bytes());
+        buf.extend_from_slice(&config.min_borrow_rate.to_le_bytes());
+        buf.extend_from_slice(&config.optimal_borrow_rate.to_le_bytes());
+        buf.extend_from_slice(&config.max_borrow_rate.to_le_bytes());
+        buf.extend_from_slice(&config.fees.borrow_fee_wad.to_le_bytes());
+        buf.extend_from_slice(&config.fees.flash_loan_fee_wad.to_le_bytes());
+        buf.extend_from_slice(&config.fees.host_fee_percentage.to_le_bytes());
+    }
 }
 
 /// Creates an 'InitLendingMarket' instruction.
@@ -982,6 +999,27 @@ pub fn flash_loan(
     }
 }
 
+/// Creates a 'ModifyReserveConfig` instruction.
+#[allow(clippy::too_many_arguments)]
+pub fn modify_reserve_config(
+    program_id: Pubkey,
+    config: ReserveConfig,
+    reserve_pubkey: Pubkey,
+    lending_market_pubkey: Pubkey,
+    lending_market_owner_pubkey: Pubkey,
+) -> Instruction {
+    let accounts = vec![
+        AccountMeta::new(reserve_pubkey, false),
+        AccountMeta::new(lending_market_pubkey, false),
+        AccountMeta::new(lending_market_owner_pubkey, true),
+    ];
+    Instruction {
+        program_id,
+        accounts,
+        data: LendingInstruction::ModifyReserveConfig { new_config: config }.pack(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1386,4 +1424,39 @@ mod tests {
             LendingInstruction::FlashLoan { amount }.pack()
         );
     }
+
+    #[test]
+    fn test_modify_reserve_config() {
+        let program_id = Pubkey::new_unique();
+        let config = ReserveConfig {
+            optimal_utilization_rate: 60,
+            loan_to_value_ratio: 1,
+            liquidation_bonus: 10,
+            liquidation_threshold: 5,
+            min_borrow_rate: 2,
+            optimal_borrow_rate: 4,
+            max_borrow_rate: 10,
+            fees: ReserveFees {
+                borrow_fee_wad: 1,
+                flash_loan_fee_wad: 3,
+                host_fee_percentage: 1,
+            },
+        };
+        let reserve_pubkey = Pubkey::new_unique();
+        let lending_market_pubkey = Pubkey::new_unique();
+        let lending_market_owner_pubkey = Pubkey::new_unique();
+        let instruction = modify_reserve_config(
+            program_id,
+            config,
+            reserve_pubkey,
+            lending_market_pubkey,
+            lending_market_owner_pubkey,
+        );
+        assert_eq!(instruction.program_id, program_id);
+        assert_eq!(instruction.accounts.len(), 3);
+        assert_eq!(
+            instruction.data,
+            LendingInstruction::ModifyReserveConfig { new_config: config }.pack()
+        );
+    }
 }

token-lending/program/src/processor.rs

@@ -3,7 +3,7 @@
 use crate::{
     error::LendingError,
     instruction::LendingInstruction,
-    math::{Decimal, Rate, TryAdd, TryDiv, TryMul, WAD},
+    math::{Decimal, Rate, TryAdd, TryDiv, TryMul},
     pyth,
     state::{
         CalculateBorrowResult, CalculateLiquidationResult, CalculateRepayResult,
@@ -99,6 +99,10 @@ pub fn process_instruction(
             msg!("Instruction: Flash Loan");
             process_flash_loan(program_id, amount, accounts)
         }
+        LendingInstruction::ModifyReserveConfig { new_config } => {
+            msg!("Instruction: Modify Reserve Config");
+            process_modify_reserve_config(program_id, new_config, accounts)
+        }
     }
 }
 
@@ -173,44 +177,8 @@ fn process_init_reserve(
         msg!("Reserve must be initialized with liquidity");
         return Err(LendingError::InvalidAmount.into());
     }
-    if config.optimal_utilization_rate > 100 {
-        msg!("Optimal utilization rate must be in range [0, 100]");
-        return Err(LendingError::InvalidConfig.into());
-    }
-    if config.loan_to_value_ratio >= 100 {
-        msg!("Loan to value ratio must be in range [0, 100)");
-        return Err(LendingError::InvalidConfig.into());
-    }
-    if config.liquidation_bonus > 100 {
-        msg!("Liquidation bonus must be in range [0, 100]");
-        return Err(LendingError::InvalidConfig.into());
-    }
-    if config.liquidation_threshold <= config.loan_to_value_ratio
-        || config.liquidation_threshold > 100
-    {
-        msg!("Liquidation threshold must be in range (LTV, 100]");
-        return Err(LendingError::InvalidConfig.into());
-    }
-    if config.optimal_borrow_rate < config.min_borrow_rate {
-        msg!("Optimal borrow rate must be >= min borrow rate");
-        return Err(LendingError::InvalidConfig.into());
-    }
-    if config.optimal_borrow_rate > config.max_borrow_rate {
-        msg!("Optimal borrow rate must be <= max borrow rate");
-        return Err(LendingError::InvalidConfig.into());
-    }
-    if config.fees.borrow_fee_wad >= WAD {
-        msg!("Borrow fee must be in range [0, 1_000_000_000_000_000_000)");
-        return Err(LendingError::InvalidConfig.into());
-    }
-    if config.fees.flash_loan_fee_wad >= WAD {
-        msg!("Flash loan fee must be in range [0, 1_000_000_000_000_000_000)");
-        return Err(LendingError::InvalidConfig.into());
-    }
-    if config.fees.host_fee_percentage > 100 {
-        msg!("Host fee percentage must be in range [0, 100]");
-        return Err(LendingError::InvalidConfig.into());
-    }
+
+    config.validate()?;
 
     let account_info_iter = &mut accounts.iter().peekable();
     let source_liquidity_info = next_account_info(account_info_iter)?;
@@ -1698,6 +1666,53 @@ fn process_flash_loan(
     Ok(())
 }
 
+fn process_modify_reserve_config(
+    program_id: &Pubkey,
+    new_config: ReserveConfig,
+    accounts: &[AccountInfo],
+) -> ProgramResult {
+    new_config.validate()?;
+
+    let account_info_iter = &mut accounts.iter().peekable();
+    let reserve_info = next_account_info(account_info_iter)?;
+    let lending_market_info = next_account_info(account_info_iter)?;
+    let lending_market_owner_info = next_account_info(account_info_iter)?;
+
+    if reserve_info.owner != program_id {
+        msg!("Reserve provided is not owned by the lending program");
+        return Err(LendingError::InvalidAccountOwner.into());
+    }
+
+    let lending_market = LendingMarket::unpack(&lending_market_info.data.borrow())?;
+    if lending_market_info.owner != program_id {
+        msg!("Lending market provided is not owned by the lending program");
+        return Err(LendingError::InvalidAccountOwner.into());
+    }
+    if &lending_market.owner != lending_market_owner_info.key {
+        msg!("Lending market owner does not match the lending market owner provided");
+        return Err(LendingError::InvalidMarketOwner.into());
+    }
+    if !lending_market_owner_info.is_signer {
+        msg!("Lending market owner provided must be a signer");
+        return Err(LendingError::InvalidSigner.into());
+    }
+
+    let mut reserve = Reserve::unpack(&reserve_info.data.borrow_mut())?;
+    // Validate that the reserve account corresponds to the correct lending market,
+    // after validating above that the lending market and lending market owner correspond,
+    // to prevent one compromised lending market owner from changing configs on other lending markets
+    if reserve.lending_market != *lending_market_info.key {
+        msg!("Reserve account does not match the lending market");
+        return Err(LendingError::InvalidAccountInput.into());
+    }
+
+    reserve.config = new_config;
+
+    Reserve::pack(reserve, &mut reserve_info.data.borrow_mut())?;
+
+    Ok(())
+}
+
 fn assert_rent_exempt(rent: &Rent, account_info: &AccountInfo) -> ProgramResult {
     if !rent.is_exempt(account_info.lamports(), account_info.data_len()) {
         msg!(&rent.minimum_balance(account_info.data_len()).to_string());