MarketFactory support fixed term

Author: ricklista

src/broker/interfaces/IBroker.sol

@@ -167,4 +167,13 @@ interface IBroker is IBrokerBase {
   /// @dev get the total debt of a user including principal and interest
   /// @param user The address of the user
   function getUserTotalDebt(address user) external view returns (uint256 totalDebt);
+
+  /// @dev set the market id for the broker, callable by owner only
+  /// @param marketId The market id to set
+  function setMarketId(Id marketId) external;
+
+  /// @dev toggle the liquidation whitelist status of an account
+  /// @param account The address of the account
+  /// @param isAddition Whether to add or remove the account from the whitelist
+  function toggleLiquidationWhitelist(address account, bool isAddition) external;
 }

src/broker/interfaces/IRateCalculator.sol

@@ -25,6 +25,8 @@ interface IRateCalculator {
    */
   function getRate(address broker) external view returns (uint256);
 
+  function registerBroker(address _broker, uint256 _ratePerSecond, uint256 _maxRatePerSecond) external;
+
   /// ------------------------------
   ///            Events
   /// ------------------------------

src/moolah/MarketFactory.sol

@@ -10,10 +10,23 @@ import { IBuyBack } from "moolah/interfaces/IBuyBack.sol";
 import { IListaAutoBuyBack } from "moolah/interfaces/IListaAutoBuyBack.sol";
 import { IPublicLiquidator } from "liquidator/IPublicLiquidator.sol";
 import { ISmartProvider } from "../provider/interfaces/IProvider.sol";
+import { IBroker } from "../broker/interfaces/IBroker.sol";
+import { IBrokerLiquidator } from "../liquidator/IBrokerLiquidator.sol";
+import { IRateCalculator } from "../broker/interfaces/IRateCalculator.sol";
 
 contract MarketFactory is UUPSUpgradeable, AccessControlEnumerableUpgradeable {
   using MarketParamsLib for MarketParams;
 
+  struct FixedTermMarketParams {
+    address broker;
+    address loanToken;
+    address collateralToken;
+    address irm;
+    uint256 lltv;
+    uint256 ratePerSecond;
+    uint256 maxRatePerSecond;
+  }
+
   IMoolah public immutable moolah;
   ILiquidator public immutable liquidator;
   IListaRevenueDistributor public immutable revenueDistributor;
@@ -24,9 +37,15 @@ contract MarketFactory is UUPSUpgradeable, AccessControlEnumerableUpgradeable {
   address public immutable sliBNB;
   address public immutable BNBProvider;
   address public immutable slisBNBProvider;
+  IRateCalculator public immutable rateCalculator;
+  IBrokerLiquidator public immutable brokerLiquidator;
 
   bytes32 public constant OPERATOR = keccak256("OPERATOR");
+  bytes32 public constant PAUSER = keccak256("PAUSER");
+  bytes32 public constant BOT = keccak256("BOT");
 
+  event BrokerMarketDeployed(FixedTermMarketParams fixedTermMarketParams, Id marketId, address broker);
+  event CommonMarketDeployed(MarketParams marketParams, Id marketId);
   /**
    * @dev constructor to set immutable variables
    * @param _moolah The address of the Moolah contract
@@ -39,6 +58,8 @@ contract MarketFactory is UUPSUpgradeable, AccessControlEnumerableUpgradeable {
    * @param _sliBNB The address of the sliBNB token
    * @param _BNBProvider The address of the BNB provider
    * @param _slisBNBProvider The address of the slisBNB provider
+   * @param _rateCalculator The address of the rate calculator contract
+   * @param _brokerLiquidator The address of the broker liquidator contract
    */
   constructor(
     address _moolah,
@@ -50,7 +71,9 @@ contract MarketFactory is UUPSUpgradeable, AccessControlEnumerableUpgradeable {
     address _WBNB,
     address _sliBNB,
     address _BNBProvider,
-    address _slisBNBProvider
+    address _slisBNBProvider,
+    address _rateCalculator,
+    address _brokerLiquidator
   ) {
     // sanity check for constructor arguments
     require(_moolah != address(0), "ZeroAddress");
@@ -63,6 +86,7 @@ contract MarketFactory is UUPSUpgradeable, AccessControlEnumerableUpgradeable {
     require(_sliBNB != address(0), "ZeroAddress");
     require(_BNBProvider != address(0), "ZeroAddress");
     require(_slisBNBProvider != address(0), "ZeroAddress");
+    require(_rateCalculator != address(0), "ZeroAddress");
     // set immutable variables
     moolah = IMoolah(_moolah);
     liquidator = ILiquidator(_liquidator);
@@ -74,6 +98,8 @@ contract MarketFactory is UUPSUpgradeable, AccessControlEnumerableUpgradeable {
     sliBNB = _sliBNB;
     BNBProvider = _BNBProvider;
     slisBNBProvider = _slisBNBProvider;
+    rateCalculator = IRateCalculator(_rateCalculator);
+    brokerLiquidator = IBrokerLiquidator(_brokerLiquidator);
 
     _disableInitializers();
   }
@@ -85,6 +111,7 @@ contract MarketFactory is UUPSUpgradeable, AccessControlEnumerableUpgradeable {
    */
   function initialize(address admin, address operator) public initializer {
     require(admin != address(0) && operator != address(0), "ZeroAddress");
+    require(operator != address(0), "ZeroAddress");
     __AccessControl_init();
 
     _grantRole(DEFAULT_ADMIN_ROLE, admin);
@@ -143,6 +170,30 @@ contract MarketFactory is UUPSUpgradeable, AccessControlEnumerableUpgradeable {
     _createMarket(param, liquidatorWhitelist, supplyWhitelist, liquidatorMarketWhitelist, liquidatorSmartProvider);
   }
 
+  /**
+   * @dev Creates new fixed term markets with the given parameters and configures the related contracts
+   * @param params An array of FixedTermMarketParams for the markets to be created
+   */
+  function batchCreateFixedTermMarkets(
+    FixedTermMarketParams[] calldata params
+  ) external onlyRole(OPERATOR) returns (Id[] memory) {
+    require(params.length > 0, "empty market params");
+
+    Id[] memory ids = new Id[](params.length);
+    for (uint256 i = 0; i < params.length; i++) {
+      ids[i] = _createFixedTermMarket(params[i]);
+    }
+    return ids;
+  }
+
+  /**
+   * @dev Creates a new fixed term market with the given parameters and configures the related contracts
+   * @param param The FixedTermMarketParams for the market to be created
+   */
+  function createFixedTermMarket(FixedTermMarketParams calldata param) external onlyRole(OPERATOR) returns (Id) {
+    return _createFixedTermMarket(param);
+  }
+
   function _createMarket(
     MarketParams memory param,
     address[] memory liquidatorWhitelist,
@@ -209,6 +260,50 @@ contract MarketFactory is UUPSUpgradeable, AccessControlEnumerableUpgradeable {
     if (liquidatorSmartProvider) {
       _configSmartProvider(id, param.oracle, param.collateralToken);
     }
+
+    emit CommonMarketDeployed(param, id);
+  }
+
+  function _createFixedTermMarket(FixedTermMarketParams memory param) private returns (Id id) {
+    IBroker broker = IBroker(param.broker);
+    require(param.broker != address(0), "Zero broker address");
+
+    // moolah create market
+    MarketParams memory marketParam = MarketParams({
+      loanToken: param.loanToken,
+      collateralToken: param.collateralToken,
+      oracle: param.broker,
+      irm: param.irm,
+      lltv: param.lltv
+    });
+    moolah.createMarket(marketParam);
+    Id id = marketParam.id();
+
+    // moolah set liquidation whitelist
+    Id[] memory ids = new Id[](1);
+    ids[0] = id;
+    address[][] memory whitelist = new address[][](1);
+    whitelist[0] = new address[](1);
+    whitelist[0][0] = param.broker;
+    moolah.batchToggleLiquidationWhitelist(ids, whitelist, true);
+
+    // broker set market id
+    broker.setMarketId(id);
+
+    // broker set liquidator whitelist
+    broker.toggleLiquidationWhitelist(address(brokerLiquidator), true);
+
+    // moolah set broker
+    moolah.setMarketBroker(id, param.broker, true);
+
+    // rate calculator register broker
+    rateCalculator.registerBroker(param.broker, param.ratePerSecond, param.maxRatePerSecond);
+
+    // broker liquidator set market whitelist
+    brokerLiquidator.setMarketToBroker(Id.unwrap(id), param.broker, true);
+
+    emit BrokerMarketDeployed(param, id, param.broker);
+    return id;
   }
 
   function _configSmartProvider(Id id, address provider, address collateral) private {

test/moolah/MarketFactoryTest.sol

@@ -18,6 +18,9 @@ import { ERC20Mock } from "moolah/mocks/ERC20Mock.sol";
 import { MockProvider } from "./mocks/MockProvider.sol";
 import { OracleMock } from "moolah/mocks/OracleMock.sol";
 import { MockSmartProvider } from "./mocks/MockSmartProvider.sol";
+import { RateCalculator, RateConfig } from "../../src/broker/RateCalculator.sol";
+import { BrokerLiquidator } from "../../src/liquidator/BrokerLiquidator.sol";
+import { LendingBroker } from "../../src/broker/LendingBroker.sol";
 
 contract MarketFactoryTest is Test {
   using MarketParamsLib for MarketParams;
@@ -35,6 +38,8 @@ contract MarketFactoryTest is Test {
   ERC20Mock WBNB;
   ERC20Mock slisBNB;
   OracleMock oracle;
+  RateCalculator rateCalculator;
+  BrokerLiquidator brokerLiquidator;
 
   address admin;
   address manager;
@@ -67,6 +72,20 @@ contract MarketFactoryTest is Test {
     );
     irm = InterestRateModel(address(irmProxy));
 
+    RateCalculator rateCalculatorImpl = new RateCalculator();
+    ERC1967Proxy rateCalculatorProxy = new ERC1967Proxy(
+      address(rateCalculatorImpl),
+      abi.encodeWithSelector(rateCalculatorImpl.initialize.selector, admin, manager, bot)
+    );
+    rateCalculator = RateCalculator(address(rateCalculatorProxy));
+
+    BrokerLiquidator brokerLiquidatorImpl = new BrokerLiquidator(address(moolah));
+    ERC1967Proxy brokerLiquidatorProxy = new ERC1967Proxy(
+      address(brokerLiquidatorImpl),
+      abi.encodeWithSelector(brokerLiquidatorImpl.initialize.selector, admin, manager, bot)
+    );
+    brokerLiquidator = BrokerLiquidator(address(brokerLiquidatorProxy));
+
     liquidator = new MockLiquidator();
     publicLiquidator = new MockLiquidator();
     listaRevenueDistributor = new MockListaRevenueDistributor();
@@ -90,7 +109,9 @@ contract MarketFactoryTest is Test {
       address(WBNB),
       address(slisBNB),
       address(bnbProvider),
-      address(slisBNBProvider)
+      address(slisBNBProvider),
+      address(rateCalculator),
+      address(brokerLiquidator)
     );
     ERC1967Proxy marketFactoryProxy = new ERC1967Proxy(
       address(marketFactoryImpl),
@@ -106,6 +127,8 @@ contract MarketFactoryTest is Test {
     vm.startPrank(admin);
     moolah.grantRole(moolah.OPERATOR(), address(marketFactory));
     moolah.grantRole(moolah.MANAGER(), address(marketFactory));
+    rateCalculator.grantRole(rateCalculator.MANAGER(), address(marketFactory));
+    brokerLiquidator.grantRole(brokerLiquidator.MANAGER(), address(marketFactory));
     vm.stopPrank();
   }
 
@@ -427,4 +450,65 @@ contract MarketFactoryTest is Test {
       "Provider mismatch for BNB market"
     );
   }
+
+  function testCreateFixedTermMarket() public {
+    address relayer = makeAddr("relayer");
+    uint256 ratePerSecond = 1000000000195993755570992534;
+    uint256 maxRatePerSecond = 1000000008319516284844716199;
+    ERC20Mock loanToken = new ERC20Mock();
+    ERC20Mock collateralToken = new ERC20Mock();
+    LendingBroker broker = newLendingBroker(relayer);
+
+    MarketFactory.FixedTermMarketParams memory params = MarketFactory.FixedTermMarketParams({
+      broker: address(broker),
+      loanToken: address(loanToken),
+      collateralToken: address(collateralToken),
+      irm: address(irm),
+      lltv: lltv80,
+      ratePerSecond: ratePerSecond,
+      maxRatePerSecond: maxRatePerSecond
+    });
+    oracle.setPrice(address(loanToken), 1e8);
+    oracle.setPrice(address(collateralToken), 1e8);
+
+    vm.startPrank(admin);
+    broker.grantRole(broker.MANAGER(), address(marketFactory));
+    vm.stopPrank();
+
+    vm.startPrank(operator);
+    Id id = marketFactory.createFixedTermMarket(params);
+    vm.stopPrank();
+
+    assertEq(Id.unwrap(id), Id.unwrap(broker.MARKET_ID()), "Market ID mismatch between broker and market factory");
+    assertEq(moolah.brokers(id), address(broker), "Broker not set for market");
+    assertTrue(moolah.isLiquidationWhitelist(id, address(broker)), "Broker should be in liquidation whitelist");
+    assertEq(
+      broker.getLiquidationWhitelist()[0],
+      address(brokerLiquidator),
+      "Liquidation whitelist mismatch for broker"
+    );
+    assertEq(
+      brokerLiquidator.brokerToMarketId(address(broker)),
+      Id.unwrap(id),
+      "Market ID mismatch in broker liquidator"
+    );
+  }
+
+  function newLendingBroker(address replayer) private returns (LendingBroker) {
+    LendingBroker lendingBrokerImpl = new LendingBroker(address(moolah), replayer, address(oracle));
+    ERC1967Proxy lendingBrokerProxy = new ERC1967Proxy(
+      address(lendingBrokerImpl),
+      abi.encodeWithSelector(
+        lendingBrokerImpl.initialize.selector,
+        admin,
+        manager,
+        bot,
+        pauser,
+        address(rateCalculator),
+        100
+      )
+    );
+
+    return LendingBroker(address(lendingBrokerProxy));
+  }
 }