[VEN-2356]: NativeTokenGateway Contract

contracts/Comptroller.sol

@@ -47,7 +47,7 @@
 {
     // PoolRegistry, immutable to save on gas
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
     address public immutable poolRegistry;
 
     /// @notice Emitted when an account enters a market
     event MarketEntered(VToken indexed vToken, address indexed account);
@@ -98,6 +98,9 @@
     /// @notice Emitted when forced liquidation is enabled or disabled for a market
     event IsForcedLiquidationEnabledUpdated(address indexed vToken, bool enable);
 
+    /// @notice Emitted when the borrowing or redeeming delegate rights are updated for an account
+    event DelegateUpdated(address indexed approver, address indexed delegate, bool approved);
+
     /// @notice Thrown when collateral factor exceeds the upper bound
     error InvalidCollateralFactor();
 
@@ -155,6 +158,9 @@
     /// @notice Thrown if the borrow cap is exceeded
     error BorrowCapExceeded(address market, uint256 cap);
 
+    /// @notice Thrown if delegate approval status is already set to the requested value
+    error DelegationStatusUnchanged();
+
     /// @param poolRegistry_ Pool registry address
     /// @custom:oz-upgrades-unsafe-allow constructor
     /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero
@@ -199,6 +205,30 @@
         return results;
     }
 
+    /**
+     * @notice Grants or revokes the borrowing or redeeming delegate rights to / from an account
+     *  If allowed, the delegate will be able to borrow funds on behalf of the sender
+     *  Upon a delegated borrow, the delegate will receive the funds, and the borrower
+     *  will see the debt on their account
+     *  Upon a delegated redeem, the delegate will receive the redeemed amount and the approver
+     *  will see a deduction in his vToken balance
+     * @param delegate The address to update the rights for
+     * @param approved Whether to grant (true) or revoke (false) the borrowing or redeeming rights
+     * @custom:event DelegateUpdated emits on success
+     * @custom:error ZeroAddressNotAllowed is thrown when delegate address is zero
+     * @custom:error DelegationStatusUnchanged is thrown if approval status is already set to the requested value
+     * @custom:access Not restricted
+     */
+    function updateDelegate(address delegate, bool approved) external {
+        ensureNonzeroAddress(delegate);
+        if (approvedDelegates[msg.sender][delegate] == approved) {
+            revert DelegationStatusUnchanged();
+        }
+
+        approvedDelegates[msg.sender][delegate] = approved;
+        emit DelegateUpdated(msg.sender, delegate, approved);
+    }
+
     /**
      * @notice Removes asset from sender's account liquidity calculation; disabling them as collateral
      * @dev Sender must not have an outstanding borrow balance in the asset,
@@ -352,7 +382,7 @@
      * @param redeemAmount The amount of the underlying asset being redeemed
      * @param redeemTokens The number of tokens being redeemed
      */
     function redeemVerify(address vToken, address redeemer, uint256 redeemAmount, uint256 redeemTokens) external {
         if (address(prime) != address(0)) {
             prime.accrueInterestAndUpdateScore(redeemer, vToken);
         }
@@ -835,7 +865,7 @@
 
         for (uint256 i; i < marketsCount; ++i) {
             (, uint256 borrowBalance, ) = _safeGetAccountSnapshot(borrowMarkets[i], borrower);
             require(borrowBalance == 0, "Nonzero borrow balance after liquidation");
         }
     }
 
@@ -847,8 +877,8 @@
      */
     function setCloseFactor(uint256 newCloseFactorMantissa) external {
         _checkAccessAllowed("setCloseFactor(uint256)");
         require(MAX_CLOSE_FACTOR_MANTISSA >= newCloseFactorMantissa, "Close factor greater than maximum close factor");
         require(MIN_CLOSE_FACTOR_MANTISSA <= newCloseFactorMantissa, "Close factor smaller than minimum close factor");
 
         uint256 oldCloseFactorMantissa = closeFactorMantissa;
         closeFactorMantissa = newCloseFactorMantissa;
@@ -923,7 +953,7 @@
      * @custom:access Controlled by AccessControlManager
      */
     function setLiquidationIncentive(uint256 newLiquidationIncentiveMantissa) external {
         require(newLiquidationIncentiveMantissa >= MANTISSA_ONE, "liquidation incentive should be greater than 1e18");
 
         _checkAccessAllowed("setLiquidationIncentive(uint256)");
 

contracts/ComptrollerInterface.sol

@@ -130,4 +130,6 @@ interface ComptrollerViewInterface {
     function borrowCaps(address) external view returns (uint256);
 
     function supplyCaps(address) external view returns (uint256);
+
+    function approvedDelegates(address user, address delegate) external view returns (bool);
 }

contracts/ComptrollerStorage.sol

@@ -114,10 +114,14 @@ contract ComptrollerStorage {
     /// Prime token address
     IPrime public prime;
 
+    /// @notice Whether the delegate is allowed to borrow or redeem on behalf of the user
+    //mapping(address user => mapping (address delegate => bool approved)) public approvedDelegates;
+    mapping(address => mapping(address => bool)) public approvedDelegates;
+
     /**
      * @dev This empty reserved space is put in place to allow future versions to add new
      * variables without shifting down storage in the inheritance chain.
      * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
      */
-    uint256[48] private __gap;
+    uint256[47] private __gap;
 }

contracts/ErrorReporter.sol

@@ -18,6 +18,7 @@ contract TokenErrorReporter {
 
     error BorrowFreshnessCheck();
     error BorrowCashNotAvailable();
+    error DelegateNotApproved();
 
     error RepayBorrowFreshnessCheck();
 

contracts/Gateway/INativeTokenGateway.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.20;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/**
+ * @title INativeTokenGateway
+ * @author Venus
+ * @notice Interface for NativeTokenGateway contract
+ */
+interface INativeTokenGateway {
+    /**
+     * @dev Emitted when native currency is supplied
+     */
+    event TokensWrappedAndSupplied(address indexed sender, address indexed vToken, uint256 amount);
+
+    /**
+     * @dev Emitted when tokens are redeemed and then unwrapped to be sent to user
+     */
+    event TokensRedeemedAndUnwrapped(address indexed sender, address indexed vToken, uint256 amount);
+
+    /**
+     * @dev Emitted when native tokens are borrowed and unwrapped
+     */
+    event TokensBorrowedAndUnwrapped(address indexed sender, address indexed vToken, uint256 amount);
+
+    /**
+     * @dev Emitted when native currency is wrapped and repaid
+     */
+    event TokensWrappedAndRepaid(address indexed sender, address indexed vToken, uint256 amount);
+
+    /**
+     * @dev Emitted when token is swept from the contract
+     */
+    event SweepToken(address indexed token, address indexed receiver, uint256 amount);
+
+    /**
+     * @dev Emitted when native asset is swept from the contract
+     */
+    event SweepNative(address indexed receiver, uint256 amount);
+
+    /**
+     * @notice Thrown if transfer of native token fails
+     */
+    error NativeTokenTransferFailed();
+
+    /**
+     * @notice Thrown if the supplied address is a zero address where it is not allowed
+     */
+    error ZeroAddressNotAllowed();
+
+    /**
+     * @notice Thrown if the supplied value is 0 where it is not allowed
+     */
+    error ZeroValueNotAllowed();
+
+    /**
+     * @dev Wrap Native Token, get wNativeToken, mint vWNativeTokens, and supply to the market
+     * @param minter The address on behalf of whom the supply is performed
+     */
+    function wrapAndSupply(address minter) external payable;
+
+    /**
+     * @dev Redeem vWNativeTokens, unwrap to Native Token, and send to the user
+     * @param redeemAmount The amount of underlying tokens to redeem
+     */
+    function redeemUnderlyingAndUnwrap(uint256 redeemAmount) external;
+
+    /**
+     * @dev Redeem vWNativeTokens, unwrap to Native Token, and send to the user
+     * @param redeemTokens The amount of vWNative tokens to redeem
+     */
+    function redeemAndUnwrap(uint256 redeemTokens) external;
+
+    /**
+     * @dev Borrow wNativeToken, unwrap to Native Token, and send to the user
+     * @param amount The amount of underlying tokens to borrow
+     */
+    function borrowAndUnwrap(uint256 amount) external;
+
+    /**
+     * @dev Wrap Native Token, repay borrow in the market, and send remaining Native Token to the user
+     */
+    function wrapAndRepay() external payable;
+
+    /**
+     * @dev Sweeps input token address tokens from the contract and sends them to the owner
+     */
+    function sweepToken(IERC20 token) external;
+
+    /**
+     * @dev Sweeps native assets (Native Token) from the contract and sends them to the owner
+     */
+    function sweepNative() external;
+}

contracts/Gateway/Interfaces/IVToken.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.20;
+
+interface IVToken {
+    function mintBehalf(address receiver, uint256 mintAmount) external returns (uint256);
+
+    function redeemUnderlyingBehalf(address redeemer, uint256 redeemAmount) external returns (uint256);
+
+    function redeemBehalf(address redeemer, uint256 redeemTokens) external returns (uint256);
+
+    function repayBorrowBehalf(address borrower, uint256 repayAmount) external returns (uint256);
+
+    function borrowBehalf(address borrower, uint256 borrowAmount) external returns (uint256);
+
+    function borrowBalanceCurrent(address account) external returns (uint256);
+
+    function underlying() external returns (address);
+
+    function exchangeRateCurrent() external returns (uint256);
+
+    function transferFrom(address from, address to, uint256 amount) external returns (bool);
+
+    function redeem(uint256 redeemTokens) external returns (uint256);
+}

contracts/Gateway/Interfaces/IWrappedNative.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.20;
+
+interface IWrappedNative {
+    function deposit() external payable;
+
+    function withdraw(uint256) external;
+
+    function approve(address guy, uint256 wad) external returns (bool);
+
+    function transferFrom(address src, address dst, uint256 wad) external returns (bool);
+
+    function transfer(address dst, uint256 wad) external returns (bool);
+
+    function balanceOf(address account) external view returns (uint256);
+}