RACE #29 Of The Secureum Bootcamp Epoch∞

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;

import "@openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin-contracts/contracts/interfaces/IERC4626.sol";

interface IOracle {
   function getCollateralPrice(address borrower, address _asset) external returns(uint256); // Returns collateral price in the specific feed's pair decimal value
   function getCollateralWeight(address _asset) external returns(uint256); // per collateral weight 1e5 == 100% of the collateral value is considered as valid collateral, this scales depending on the strength of the collateral.
}

interface IBigMoneyVault is IERC4626 {
   function lend(uint256 amount) external;
   function repay(uint256 amount) external;
   function getToken() external view returns(address);
}

contract InSecureumLender is ReentrancyGuard {
   using SafeERC20 for ERC20;
   // Data Structures
   struct Borrower {
       uint256 debt;
       uint256 previousInterestTimestamp;
       mapping(address  => uint256) collateralValues; // maps collateral tokens to value deposited
       address[] activeCollaterals;
   }

   mapping(address => Borrower) public borrowers;
   mapping(address => bool) public approvedCollaterals;

   address token;
   uint256 DECIMALS = 1e18;

   // Access Control
   address public owner;

   // Network Contracts;
   IBigMoneyVault public bigMoneyVault;
   IOracle public priceOracle;
   address public liquidator;

   // Modifiers
   modifier onlyBigMoney {
       require(msg.sender == address(bigMoneyVault));
       _;
   }

   modifier onlyOwner {
       require(msg.sender == owner);
       _;
   }

   // Finance Metrics
   uint256[] public collateralisationMinimumValue;
   uint256 public constant INTEREST_RATE = 333; // 1.05 (ie 5%) annualised converted to per second
   uint256 public constant RATE_PRECISION = 1e10;
   constructor(address _bigMoneyVault, address _liquidator, address _priceOracle) {
       owner = msg.sender;
       bigMoneyVault = IBigMoneyVault(_bigMoneyVault);
       priceOracle = IOracle(_priceOracle);
       token = bigMoneyVault.getToken();
       liquidator = _liquidator; // separate ERC4626 contract where liquidations could be divided based on shares, any bad debt absorbance is handled, this is mainly an abstraction to simplify Liquidations for the Secureum Race.
   }

   function borrow(uint256 amount) public {
       Borrower storage account = borrowers[msg.sender];
      
       // health check and interest recalculation
       require(healthCheck(msg.sender), "Account below liquidation threshold");
       applyInterest(msg.sender);
      
       // Increment Debt, transfer funds
       account.debt += amount;
       bigMoneyVault.lend(amount);
   }

   // Assumes allowed transfer amount
   function repay(address _borrower, uint256 _amount) public {
       Borrower storage borrowerAccount = borrowers[_borrower];
       applyInterest(_borrower);


       ERC20(token).safeTransferFrom(msg.sender, address(this), _amount);
       borrowerAccount.debt -= _amount;
   }

   function depositCollateral(address collateralToken, uint256 amount) nonReentrant public {
       require(approvedCollaterals[collateralToken], "Collateral not approved");
      
       ERC20(collateralToken).safeTransferFrom(msg.sender, address(this), amount);
       Borrower storage account = borrowers[msg.sender];


       if (account.collateralValues[collateralToken] == 0) {
           account.activeCollaterals.push(collateralToken);
       }
      
       account.collateralValues[collateralToken] += amount;
   }

   function batchDepositCollaterals(address[] calldata collateralTokens, address[] calldata users, uint256[] calldata amounts) nonReentrant public {
       for(uint256 i=0; i < amounts.length;) {
           if(approvedCollaterals[collateralTokens[i]]) {
               borrowers[users[i]].collateralValues[collateralTokens[i]] += amounts[i];
               ERC20(collateralTokens[i]).safeTransferFrom(users[i], address(this), amounts[i]);
              
           }           

           unchecked {
               ++i;
           }
       }
   }

   // User can only withdraw collateral once all debt has been repayed
   function withdrawCollateral(address[] calldata collateralTokens) public {
       Borrower storage account = borrowers[msg.sender];

       require(account.debt == 0, "Account still in debt");

       for(uint256 i=0; i<collateralTokens.length;) {
           ERC20(collateralTokens[i]).safeTransfer(msg.sender, account.collateralValues[collateralTokens[i]]);
       }

       // Since debt == 0 now and collateral has been transferred lets delete the account struct
       delete borrowers[msg.sender];
   }

   function liquidate(address borrower) public {
       Borrower storage account = borrowers[borrower];
       if(!healthCheck(borrower))
           for(uint256 i=0; i<account.activeCollaterals.length; i++) {
               ERC20(account.activeCollaterals[i]).safeTransfer(liquidator, account.collateralValues[account.activeCollaterals[i]]);
           }

           account.debt = 0;
   }

   function applyInterest(address BorrowerAddress) public {
       Borrower storage account = borrowers[BorrowerAddress];
      
       uint256 deltaTimestamp = (block.timestamp - account.previousInterestTimestamp);
       uint256 newDebt = ( account.debt * INTEREST_RATE * deltaTimestamp ) / RATE_PRECISION;
      
       account.debt = newDebt;
       account.previousInterestTimestamp = block.timestamp;
   }

   function healthCheck(address borrower) public returns(bool) {
       Borrower storage account = borrowers[borrower];
       uint256 cumulativeCollateralScore = 0;

       for(uint256 index = 0; index < account.activeCollaterals.length; ++index) {
           if(approvedCollaterals[account.activeCollaterals[index]]) {

               uint256 quotePrice = priceOracle.getCollateralPrice(borrower, account.activeCollaterals[index]);
               uint256 scaledPrice = quotePrice / DECIMALS;
               uint256 collateralWeight = priceOracle.getCollateralWeight(account.activeCollaterals[index]);
              
               cumulativeCollateralScore += scaledPrice * collateralWeight;
           }
       }

       return cumulativeCollateralScore / account.activeCollaterals.length >= 5e4;
   }

   function approveCollaterals(address _collateral, bool _approve) onlyOwner external {
       approvedCollaterals[_collateral] = _approve;
   }

   function getBorrowerActiveCollateral(address _borrower) external view returns(address[] memory) {
       Borrower storage borrower = borrowers[_borrower];
       address[] memory activeCollaterals = borrower.activeCollaterals;

       return activeCollaterals;
   }

   function getAccountDebt(address _borrower) external view returns(uint256) {
       Borrower storage borrower = borrowers[_borrower];

       return borrower.debt;
   }
}