Interfaces for erc20 and lendingPool

contracts/interfaces/IIncentiveController.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.16;
+
+import './IStaderConfig.sol';
+
+interface IIncentiveController {
+
+    // events
+    event UpdatedStaderConfig(address staderConfig);
+
+    // functions
+    function claim(address account) external;
+
+    function onDeposit(address account) external;
+
+    function rewardPerToken() external view returns (uint256);
+
+    function earned(address account) external view returns (uint256);
+}

contracts/interfaces/ILendingPool.sol

@@ -3,6 +3,13 @@ pragma solidity 0.8.16;
 
 import './IStaderConfig.sol';
 
+struct UserData {
+    uint256 totalInterestSD;
+    uint256 totalCollateralInSD;
+    uint256 ltv;
+    uint256 healthFactor;
+}
+
 interface ILendingPool {
 
     // events
@@ -11,8 +18,17 @@ interface ILendingPool {
     // functions
     function deposit(uint256 amount) external returns (uint256);
 
-    function withdraw(uint256 amount) external returns (uint256);
+    function requestWithdraw(uint256 amount) external returns (uint256);
 
     function claim(uint256 index) external returns (uint256);
 
+    function borrow(uint256 amount) external returns (uint256);
+
+    function repay(uint256 amount) external returns (uint256);
+
+    function liquidationCall(address account) external returns (uint256);
+
+    function claimLiquidation(uint256 index) external returns (uint256);
+
+    function getUserData(address account) external view returns (UserData memory);
 }

contracts/interfaces/ILendingPoolToken.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.16;
+
+interface ILendingPoolToken {
+    function mint(address account, uint256 amount) external;
+
+    function burn(address account, uint256 amount) external;
+}

contracts/lendingpool/IncentiveController.sol

@@ -6,10 +6,11 @@ import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
 
 import '../library/UtilLib.sol';
 import '../interfaces/IStaderConfig.sol';
+import '../interfaces/IIncentiveController.sol';
 
 /// @title IncentiveController
 /// @notice This contract handles the distribution of reward tokens for a lending pool.
-contract IncentiveController is AccessControlUpgradeable {
+contract IncentiveController is IIncentiveController, AccessControlUpgradeable {
     // The emission rate of the reward tokens per second.
     uint256 public emissionPerSecond;
 

contracts/lendingpool/LendingPool.sol

@@ -4,23 +4,52 @@ pragma solidity 0.8.16;
 import '@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol';
 
 import '../interfaces/ILendingPool.sol';
+import '../interfaces/IIncentiveController.sol';
+import '../interfaces/ILendingPoolToken.sol';
 
-contract LendingPool is ILendingPool, AccessControlUpgradeable { 
+contract LendingPool is ILendingPool, AccessControlUpgradeable {
+    IIncentiveController public incentiveController;
+    ILendingPoolToken public lendingPoolToken;
 
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor() {
         _disableInitializers();
     }
 
     function deposit(uint256 amount) external override returns (uint256) {
+        incentiveController.onDeposit(msg.sender);
+        lendingPoolToken.mint(msg.sender, amount);
         return 0;
     }
 
-    function withdraw(uint256 amount) external override returns (uint256) {
+    function requestWithdraw(uint256 amount) external override returns (uint256) {
+        incentiveController.claim(msg.sender);
+        lendingPoolToken.burn(msg.sender, amount);
         return 0;
     }
 
     function claim(uint256 index) external override returns (uint256) {
+        incentiveController.claim(msg.sender);
         return 0;
     }
+
+    function borrow(uint256 amount) external override returns (uint256) {
+        return 0;
+    }
+
+    function repay(uint256 amount) external override returns (uint256) {
+        return 0;
+    }
+
+    function liquidationCall(address account) external override returns (uint256) {
+        return 0;
+    }
+
+    function claimLiquidation(uint256 index) external override returns (uint256) {
+        return 0;
+    }
+
+    function getUserData(address account) external override view returns (UserData memory) {
+        return UserData(0, 0, 0, 0);
+    }
 }

contracts/lendingpool/SDX.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.16;
+
+import '@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol';
+import '@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol';
+import '@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol';
+
+import '../interfaces/IStaderConfig.sol';
+import '../library/UtilLib.sol';
+
+contract SDX is Initializable, AccessControlUpgradeable, ERC20Upgradeable, PausableUpgradeable{
+    event UpdatedStaderConfig(address indexed _staderConfig);
+
+    IStaderConfig public staderConfig;
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address _admin, address _staderConfig) external initializer {
+        UtilLib.checkNonZeroAddress(_admin);
+        UtilLib.checkNonZeroAddress(_staderConfig);
+
+        __ERC20_init('Interest bearing SD token', 'SDx');
+        __Pausable_init();
+        __AccessControl_init();
+
+        staderConfig = IStaderConfig(_staderConfig);
+        _grantRole(DEFAULT_ADMIN_ROLE, _admin);
+
+        emit UpdatedStaderConfig(_staderConfig);
+    }
+
+    /**
+     * @notice Mints SDx when called by an authorized caller
+     * @param to the account to mint to
+     * @param amount the amount of SDx to mint
+     */
+    function mint(address to, uint256 amount) external whenNotPaused {
+        UtilLib.onlyStaderContract(msg.sender, staderConfig, staderConfig.LENDING_POOL_CONTRACT());
+
+        _mint(to, amount);
+    }
+
+    /**
+     * @notice Burns SDx when called by an authorized caller
+     * @param account the account to burn from
+     * @param amount the amount of SDx to burn
+     */
+    function burnFrom(address account, uint256 amount) external whenNotPaused {
+        UtilLib.onlyStaderContract(msg.sender, staderConfig, staderConfig.LENDING_POOL_CONTRACT());
+
+        _burn(account, amount);
+    }
+
+    /**
+     * @dev Triggers stopped state.
+     * Contract must not be paused.
+     */
+    function pause() external {
+        UtilLib.onlyManagerRole(msg.sender, staderConfig);
+
+        _pause();
+    }
+
+    /**
+     * @dev Returns to normal state.
+     * Contract must be paused
+     */
+    function unpause() external {
+        UtilLib.onlyManagerRole(msg.sender, staderConfig);
+
+        _unpause();
+    }
+
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override whenNotPaused {
+        super._beforeTokenTransfer(from, to, amount);
+    }
+
+    function updateStaderConfig(address _staderConfig) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        UtilLib.checkNonZeroAddress(_staderConfig);
+        staderConfig = IStaderConfig(_staderConfig);
+        emit UpdatedStaderConfig(_staderConfig);
+    }
+}