[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 delegate rights are updated for an account
+    event DelegateUpdated(address indexed user, address indexed delegate, bool allowDelegate);
+
     /// @notice Thrown when collateral factor exceeds the upper bound
     error InvalidCollateralFactor();
 
@@ -199,6 +202,25 @@
         return results;
     }
 
+    /**
+     * @notice Grants or revokes the borrowing delegate rights to / from an account
+     *  If allowed, the delegate will be able to borrow/redeem 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 redeem the vTokens or the underlying,
+     *  will receive the redeemed amount on behalf of the approver(redeemer)
+     * @param delegate The address to update the rights for
+     * @param allowBorrows Whether to grant (true) or revoke (false) the rights
+     * @custom:event DelegateUpdated emits on success
+     * @custom:error ZeroAddressNotAllowed is thrown when delegate address is zero
+     * @custom:access Not restricted
+     */
+    function updateDelegate(address delegate, bool allowBorrows) external {
+        ensureNonzeroAddress(delegate);
+        approvedDelegates[msg.sender][delegate] = allowBorrows;
+        emit DelegateUpdated(msg.sender, delegate, allowBorrows);
+    }
+
     /**
      * @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 +374,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 +857,7 @@
 
         for (uint256 i; i < marketsCount; ++i) {
             (, uint256 borrowBalance, ) = _safeGetAccountSnapshot(borrowMarkets[i], borrower);
             require(borrowBalance == 0, "Nonzero borrow balance after liquidation");
         }
     }
 
@@ -847,8 +869,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 +945,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

@@ -116,4 +116,6 @@ interface ComptrollerViewInterface {
     function borrowCaps(address) external view returns (uint256);
 
     function supplyCaps(address) external view returns (uint256);
+
+    function approvedDelegates(address borrower, address receiver) external view returns (bool);
 }

contracts/ComptrollerStorage.sol

@@ -125,10 +125,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,87 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.20;
+
+/**
+ * @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 wNativeToken is swept from the contract
+     */
+    event SweepToken(address indexed sender, uint256 amount);
+
+    /**
+     * @dev Emitted when native asset is swept from the contract
+     */
+    event SweepNative(address indexed sender, 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 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 wNativeToken tokens from the contract and sends them to the owner
+     */
+    function sweepToken() 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,22 @@
+// 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 repayBorrowBehalf(address borrower, uint256 repayAmount) external returns (uint256);
+
+    function borrowBalanceCurrent(address account) external returns (uint256);
+
+    function borrowBehalf(address borrower, uint256 borrowAmount) 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);
+}

contracts/Gateway/NativeTokenGateway.sol

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.20;
+
+import { Ownable2Step } from "@openzeppelin/contracts/access/Ownable2Step.sol";
+import { SafeERC20, IERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+
+import { IWrappedNative } from "./Interfaces/IWrappedNative.sol";
+import { INativeTokenGateway } from "./INativeTokenGateway.sol";
+import { IVToken } from "./Interfaces/IVToken.sol";
+
+/**
+ * @title NativeTokenGateway
+ * @author Venus
+ * @notice NativeTokenGateway contract facilitates interactions with a vToken market for native tokens (Native or wNativeToken)
+ */
+contract NativeTokenGateway is INativeTokenGateway, Ownable2Step, ReentrancyGuard {
+    using SafeERC20 for IERC20;
+
+    /**
+     * @notice Address of wrapped native token contract
+     */
+    IWrappedNative public immutable wNativeToken;
+
+    /**
+     * @notice Address of wrapped native token market
+     */
+    IVToken public immutable vWNativeToken;
+
+    /**
+     * @notice Constructor for NativeTokenGateway
+     * @param vWrappedNativeToken Address of wrapped native token market
+     */
+    constructor(IVToken vWrappedNativeToken) {
+        ensureNonzeroAddress(address(vWrappedNativeToken));
+
+        vWNativeToken = vWrappedNativeToken;
+        wNativeToken = IWrappedNative(vWNativeToken.underlying());
+    }
+
+    /**
+     * @notice To receive Native when msg.data is empty
+     */
+    receive() external payable {}
+
+    /**
+     * @notice To receive Native when msg.data is not empty
+     */
+    fallback() external payable {}
+
+    /**
+     * @notice Wrap Native, get wNativeToken, mint vWNativeToken, and supply to the market.
+     * @param minter The address on behalf of whom the supply is performed.
+     * @custom:error ZeroAddressNotAllowed is thrown if address of minter is zero address
+     * @custom:error ZeroValueNotAllowed is thrown if mintAmount is zero
+     * @custom:event TokensWrappedAndSupplied is emitted when assets are supplied to the market
+     */
+    function wrapAndSupply(address minter) external payable nonReentrant {
+        ensureNonzeroAddress(minter);
+
+        uint256 mintAmount = msg.value;
+        ensureNonzeroValue(mintAmount);
+
+        wNativeToken.deposit{ value: mintAmount }();
+        IERC20(address(wNativeToken)).safeApprove(address(vWNativeToken), mintAmount);
+
+        vWNativeToken.mintBehalf(minter, mintAmount);
+
+        IERC20(address(wNativeToken)).safeApprove(address(vWNativeToken), 0);
+        emit TokensWrappedAndSupplied(minter, address(vWNativeToken), mintAmount);
+    }
+
+    /**
+     * @notice Redeem vWNativeToken, unwrap to Native Token, and send to the user
+     * @param redeemAmount The amount of underlying tokens to redeem
+     * @custom:error ZeroValueNotAllowed is thrown if redeemAmount is zero
+     * @custom:event TokensRedeemedAndUnwrapped is emitted when assets are redeemed from a market and unwrapped
+     */
+    function redeemUnderlyingAndUnwrap(uint256 redeemAmount) external nonReentrant {
+        ensureNonzeroValue(redeemAmount);
+
+        uint256 balanceBefore = wNativeToken.balanceOf(address(this));
+        vWNativeToken.redeemUnderlyingBehalf(msg.sender, redeemAmount);
+        uint256 balanceAfter = wNativeToken.balanceOf(address(this));
+
+        uint256 redeemedAmount = balanceAfter - balanceBefore;
+        wNativeToken.withdraw(redeemedAmount);
+
+        _safeTransferNativeTokens(msg.sender, redeemedAmount);
+        emit TokensRedeemedAndUnwrapped(msg.sender, address(vWNativeToken), redeemedAmount);
+    }
+
+    /**
+     * @dev Borrow wNativeToken, unwrap to Native, and send to the user
+     * @param borrowAmount The amount of underlying tokens to borrow
+     * @custom:error ZeroValueNotAllowed is thrown if borrowAmount is zero
+     * @custom:event TokensBorrowedAndUnwrapped is emitted when assets are borrowed from a market and unwrapped
+     */
+    function borrowAndUnwrap(uint256 borrowAmount) external nonReentrant {
+        ensureNonzeroAddress(address(vWNativeToken));
+        ensureNonzeroValue(borrowAmount);
+
+        vWNativeToken.borrowBehalf(msg.sender, borrowAmount);
+
+        wNativeToken.withdraw(borrowAmount);
+        _safeTransferNativeTokens(msg.sender, borrowAmount);
+        emit TokensBorrowedAndUnwrapped(msg.sender, address(vWNativeToken), borrowAmount);
+    }
+
+    /**
+     * @notice Wrap Native, repay borrow in the market, and send remaining Native to the user
+     * @custom:error ZeroValueNotAllowed is thrown if repayAmount is zero
+     * @custom:event TokensWrappedAndRepaid is emitted when assets are repaid to a market and unwrapped
+     */
+    function wrapAndRepay() external payable nonReentrant {
+        uint256 repayAmount = msg.value;
+        ensureNonzeroValue(repayAmount);
+
+        wNativeToken.deposit{ value: repayAmount }();
+        IERC20(address(wNativeToken)).safeApprove(address(vWNativeToken), repayAmount);
+
+        uint256 borrowBalanceBefore = vWNativeToken.borrowBalanceCurrent(msg.sender);
+        vWNativeToken.repayBorrowBehalf(msg.sender, repayAmount);
+        uint256 borrowBalanceAfter = vWNativeToken.borrowBalanceCurrent(msg.sender);
+
+        IERC20(address(wNativeToken)).safeApprove(address(vWNativeToken), 0);
+
+        if (borrowBalanceAfter == 0 && (repayAmount > borrowBalanceBefore)) {
+            uint256 dust = repayAmount - borrowBalanceBefore;
+
+            wNativeToken.withdraw(dust);
+            _safeTransferNativeTokens(msg.sender, dust);
+        }
+        emit TokensWrappedAndRepaid(msg.sender, address(vWNativeToken), borrowBalanceBefore - borrowBalanceAfter);
+    }
+
+    /**
+     * @notice Sweeps native assets (Native) from the contract and sends them to the owner
+     * @custom:event SweepNative is emitted when assets are swept from the contract
+     * @custom:access Controlled by Governance
+     */
+    function sweepNative() external onlyOwner {
+        uint256 balance = address(this).balance;
+
+        if (balance > 0) {
+            _safeTransferNativeTokens((owner()), balance);
+            emit SweepNative((owner()), balance);
+        }
+    }
+
+    /**
+     * @notice Sweeps wNativeToken tokens from the contract and sends them to the owner
+     * @custom:event SweepToken emits on success
+     * @custom:access Controlled by Governance
+     */
+    function sweepToken() external onlyOwner {
+        uint256 balance = wNativeToken.balanceOf(address(this));
+
+        if (balance > 0) {
+            IERC20(address(wNativeToken)).safeTransfer(owner(), balance);
+            emit SweepToken(owner(), balance);
+        }
+    }
+
+    /**
+     * @dev transfer Native tokens to an address, revert if it fails
+     * @param to recipient of the transfer
+     * @param value the amount to send
+     * @custom:error NativeTokenTransferFailed is thrown if the Native token transfer fails
+     */
+    function _safeTransferNativeTokens(address to, uint256 value) internal {
+        (bool success, ) = to.call{ value: value }(new bytes(0));
+
+        if (!success) {
+            revert NativeTokenTransferFailed();
+        }
+    }
+
+    /**
+     * @dev Checks if the provided address is nonzero, reverts otherwise
+     * @param address_ Address to check
+     * @custom:error ZeroAddressNotAllowed is thrown if the provided address is a zero address
+     **/
+    function ensureNonzeroAddress(address address_) internal pure {
+        if (address_ == address(0)) {
+            revert ZeroAddressNotAllowed();
+        }
+    }
+
+    /**
+     * @dev Checks if the provided value is nonzero, reverts otherwise
+     * @param value_ Value to check
+     * @custom:error ZeroValueNotAllowed is thrown if the provided value is 0
+     */
+    function ensureNonzeroValue(uint256 value_) internal pure {
+        if (value_ == 0) {
+            revert ZeroValueNotAllowed();
+        }
+    }
+}