@venusprotocol/protocol-reserve 1.3.0 → 1.4.0-dev.2

package/contracts/Interfaces/IComptroller.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+interface IComptroller {
+    function isComptroller() external view returns (bool);
+
+    function markets(address) external view returns (bool);
+
+    function getAllMarkets() external view returns (address[] memory);
+}

package/contracts/Interfaces/IConverterNetwork.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+import { IAbstractTokenConverter } from "../TokenConverter/IAbstractTokenConverter.sol";
+
+/**
+ * @title IConverterNetwork
+ * @author Venus
+ * @notice Interface implemented by `ConverterNetwork`.
+ */
+interface IConverterNetwork {
+    /// @notice Adds new converter to the array
+    /// @param _tokenConverter Address of the token converter
+    function addTokenConverter(IAbstractTokenConverter _tokenConverter) external;
+
+    /// @notice Removes converter from the array
+    /// @param _tokenConverter Address of the token converter
+    function removeTokenConverter(IAbstractTokenConverter _tokenConverter) external;
+
+    /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances
+    /// @param _tokenAddressIn Address of tokenIn
+    /// @param _tokenAddressOut Address of tokenOut
+    /// @return converters Array of the conveters on the basis of the tokens pair
+    /// @return convertersBalance Array of balances with respect to token out
+    function findTokenConverters(address _tokenAddressIn, address _tokenAddressOut)
+        external
+        returns (address[] memory converters, uint256[] memory convertersBalance);
+
+    /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances
+    /// @param _tokenAddressIn Address of tokenIn
+    /// @param _tokenAddressOut Address of tokenOut
+    /// @return converters Array of the conveters on the basis of the tokens pair
+    /// @return convertersBalance Array of balances with respect to token out
+    function findTokenConvertersForConverters(address _tokenAddressIn, address _tokenAddressOut)
+        external
+        returns (address[] memory converters, uint256[] memory convertersBalance);
+
+    /// @notice This function returns the array containing all the converters addresses
+    /// @return Array containing all the converters addresses
+    function getAllConverters() external view returns (IAbstractTokenConverter[] memory);
+
+    /// @notice This function checks for given address is converter or not
+    /// @param _tokenConverter Address of the token converter
+    /// @return boolean true if given address is converter otherwise false
+    function isTokenConverter(address _tokenConverter) external view returns (bool);
+}

package/contracts/Interfaces/IPoolRegistry.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+interface IPoolRegistry {
+    /// @notice Get VToken in the Pool for an Asset
+    function getVTokenForAsset(address comptroller, address asset) external view returns (address);
+
+    /// @notice Get the addresss of the Pools supported that include a market for the provided asset
+    function getPoolsSupportedByAsset(address asset) external view returns (address[] memory);
+}

package/contracts/Interfaces/IRiskFund.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+/**
+ * @title IRiskFund
+ * @author Venus
+ * @notice Interface implemented by `RiskFund`.
+ */
+interface IRiskFund {
+    function transferReserveForAuction(address comptroller, uint256 amount) external returns (uint256);
+
+    function updatePoolState(
+        address comptroller,
+        address asset,
+        uint256 amount
+    ) external;
+
+    function getPoolsBaseAssetReserves(address comptroller) external view returns (uint256);
+}
+
+/**
+ * @title IRiskFundGetters
+ * @author Venus
+ * @notice Interface implemented by `RiskFund` for getter methods.
+ */
+interface IRiskFundGetters {
+    function convertibleBaseAsset() external view returns (address);
+}

package/contracts/Interfaces/IRiskFundConverter.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+interface IRiskFundConverter {
+    function updateAssetsState(address comptroller, address asset) external;
+
+    function getPools(address asset) external view returns (address[] memory);
+}

package/contracts/Interfaces/IShortfall.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+/**
+ * @title IShortfall
+ * @author Venus
+ * @notice Interface implemented by `Shortfall`.
+ */
+interface IShortfall {
+    function convertibleBaseAsset() external returns (address);
+}

package/contracts/Interfaces/IXVSVault.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+/// @title IXVSVaultProxy
+/// @author Venus
+/// @notice Interface implemented by `XVSVault`.
+interface IXVSVault {
+    function xvsStore() external view returns (address);
+}

package/contracts/ProtocolReserve/ProtocolShareReserve.sol

@@ -5,10 +5,11 @@ import { SafeERC20Upgradeable, IERC20Upgradeable } from "@openzeppelin/contracts
 import { AccessControlledV8 } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol";
 import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 import { MaxLoopsLimitHelper } from "@venusprotocol/solidity-utilities/contracts/MaxLoopsLimitHelper.sol";
+import { ensureNonzeroAddress } from "@venusprotocol/solidity-utilities/contracts/validators.sol";
 
 import { IProtocolShareReserve } from "../Interfaces/IProtocolShareReserve.sol";
-import { ComptrollerInterface } from "../Interfaces/ComptrollerInterface.sol";
-import { PoolRegistryInterface } from "../Interfaces/PoolRegistryInterface.sol";
+import { IComptroller } from "../Interfaces/IComptroller.sol";
+import { IPoolRegistry } from "../Interfaces/IPoolRegistry.sol";
 import { IVToken } from "../Interfaces/IVToken.sol";
 import { IIncomeDestination } from "../Interfaces/IIncomeDestination.sol";
 
@@ -69,7 +70,7 @@ contract ProtocolShareReserve is
     /// @notice Emitted when pool registry address is updated
     event PoolRegistryUpdated(address indexed oldPoolRegistry, address indexed newPoolRegistry);
 
-    /// @notice Event emitted after the updation of the assets reserves.
+    /// @notice Event emitted after updating of the assets reserves.
     event AssetsReservesUpdated(
         address indexed comptroller,
         address indexed asset,
@@ -122,9 +123,9 @@ contract ProtocolShareReserve is
         address _wbnb,
         address _vbnb
     ) {
-        if (_corePoolComptroller == address(0)) revert InvalidAddress();
-        if (_wbnb == address(0)) revert InvalidAddress();
-        if (_vbnb == address(0)) revert InvalidAddress();
+        ensureNonzeroAddress(_corePoolComptroller);
+        ensureNonzeroAddress(_wbnb);
+        ensureNonzeroAddress(_vbnb);
 
         CORE_POOL_COMPTROLLER = _corePoolComptroller;
         WBNB = _wbnb;
@@ -149,9 +150,10 @@ contract ProtocolShareReserve is
     /**
      * @dev Pool registry setter.
      * @param _poolRegistry Address of the pool registry
+     * @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero
      */
     function setPoolRegistry(address _poolRegistry) external onlyOwner {
-        if (_poolRegistry == address(0)) revert InvalidAddress();
+        ensureNonzeroAddress(_poolRegistry);
         emit PoolRegistryUpdated(poolRegistry, _poolRegistry);
         poolRegistry = _poolRegistry;
     }
@@ -165,7 +167,7 @@ contract ProtocolShareReserve is
 
         for (uint256 i = 0; i < configs.length; ) {
             DistributionConfig memory _config = configs[i];
-            if (_config.destination == address(0)) revert InvalidAddress();
+            ensureNonzeroAddress(_config.destination);
 
             bool updated = false;
             uint256 distributionTargetsLength = distributionTargets.length;
@@ -313,7 +315,7 @@ contract ProtocolShareReserve is
 
     /**
      * @dev Update the reserve of the asset for the specific pool after transferring to the protocol share reserve.
-     * @param comptroller  Comptroller address(pool)
+     * @param comptroller Comptroller address (pool)
      * @param asset Asset address.
      * @param incomeType type of income
      */
@@ -322,11 +324,12 @@ contract ProtocolShareReserve is
         address asset,
         IncomeType incomeType
     ) public override(IProtocolShareReserve) nonReentrant {
-        if (!ComptrollerInterface(comptroller).isComptroller()) revert InvalidAddress();
-        if (asset == address(0)) revert InvalidAddress();
+        if (!IComptroller(comptroller).isComptroller()) revert InvalidAddress();
+        ensureNonzeroAddress(asset);
+
         if (
             comptroller != CORE_POOL_COMPTROLLER &&
-            PoolRegistryInterface(poolRegistry).getVTokenForAsset(comptroller, asset) == address(0)
+            IPoolRegistry(poolRegistry).getVTokenForAsset(comptroller, asset) == address(0)
         ) revert InvalidAddress();
 
         Schema schema = _getSchema(incomeType);

package/contracts/ProtocolReserve/RiskFundStorage.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+import { Ownable2StepUpgradeable } from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
+import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+
+/// @title ReserveHelpersStorage
+/// @author Venus
+/// @dev Reserve helpers storage
+/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion
+contract ReserveHelpersStorage is Ownable2StepUpgradeable {
+    /// @notice Deprecated slot for assetReserves mapping
+    bytes32 private __deprecatedSlot1;
+
+    /// @notice Available asset's fund per pool in RiskFund
+    /// Comptroller(pool) -> Asset -> amount
+    mapping(address => mapping(address => uint256)) public poolAssetsFunds;
+
+    /// @notice Deprecated slot for poolRegistry address
+    bytes32 private __deprecatedSlot2;
+    /// @notice Deprecated slot for status variable
+    bytes32 private __deprecatedSlot3;
+
+    /// @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.
+    uint256[46] private __gap;
+}
+
+/// @title MaxLoopsLimitHelpersStorage
+/// @author Venus
+/// @dev Max loop limit helpers storage
+/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion
+contract MaxLoopsLimitHelpersStorage {
+    /// @notice Limit for the loops to avoid the DOS
+    /// @notice This state is deprecated, using it to prevent storage collision
+    uint256 public maxLoopsLimit;
+
+    /// @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[49] private __gap;
+}
+
+/// @title RiskFundV1Storage
+/// @author Venus
+/// @dev Risk fund V1 storage
+/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion
+contract RiskFundV1Storage is ReserveHelpersStorage, MaxLoopsLimitHelpersStorage {
+    /// @notice Address of base asset
+    address public convertibleBaseAsset;
+    /// @notice Address of shortfall contract
+    address public shortfall;
+
+    /// @notice This state is deprecated, using it to prevent storage collision
+    address private pancakeSwapRouter;
+    /// @notice This state is deprecated, using it to prevent storage collision
+    uint256 private minAmountToConvert;
+}
+
+/// @title RiskFundV2Storage
+/// @author Venus
+/// @dev Risk fund V2 storage
+/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion
+contract RiskFundV2Storage is RiskFundV1Storage, ReentrancyGuardUpgradeable {
+    /// @notice Risk fund converter address
+    address public riskFundConverter;
+}

package/contracts/ProtocolReserve/RiskFundV2.sol

@@ -0,0 +1,253 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { AccessControlledV8 } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol";
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { ensureNonzeroAddress, ensureNonzeroValue } from "@venusprotocol/solidity-utilities/contracts/validators.sol";
+
+import { IRiskFund } from "../Interfaces/IRiskFund.sol";
+import { IRiskFundConverter } from "../Interfaces/IRiskFundConverter.sol";
+import { RiskFundV2Storage } from "./RiskFundStorage.sol";
+
+/// @title RiskFundV2
+/// @author Venus
+/// @notice Contract with basic features to hold base asset for different Comptrollers
+/// @dev This contract does not support BNB
+/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion
+contract RiskFundV2 is AccessControlledV8, RiskFundV2Storage, IRiskFund {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+
+    /// @notice Emitted when convertible base asset address is updated
+    event ConvertibleBaseAssetUpdated(address indexed oldConvertibleBaseAsset, address indexed newConvertibleBaseAsset);
+
+    /// @notice Emitted when risk fund converter address is updated
+    event RiskFundConverterUpdated(address indexed oldRiskFundConverter, address indexed newRiskFundConverter);
+
+    /// @notice Emitted when shortfall contract address is updated
+    event ShortfallContractUpdated(address indexed oldShortfallContract, address indexed newShortfallContract);
+
+    /// @notice Emitted when reserves are transferred for auction
+    event TransferredReserveForAuction(address indexed comptroller, uint256 amount);
+
+    /// @notice Emitted when pool asset states is updated with amount transferred to this contract
+    event PoolAssetsIncreased(address indexed comptroller, address indexed asset, uint256 amount);
+
+    /// @notice Emitted when pool asset states is updated with amount transferred from this contract on sweeping tokens
+    event PoolAssetsDecreased(address indexed comptroller, address indexed asset, uint256 amount);
+
+    /// @notice Event emitted when tokens are swept
+    event SweepToken(address indexed token, address indexed to, uint256 amount);
+
+    /// @notice Event emitted when tokens are swept and transferred from pool
+    event SweepTokenFromPool(address indexed token, address indexed comptroller, uint256 amount);
+
+    /// @notice Error is thrown when updatePoolState is not called by riskFundConverter
+    error InvalidRiskFundConverter();
+
+    /// @notice Error is thrown when transferReserveForAuction is called by non shortfall address
+    error InvalidShortfallAddress();
+
+    /// @notice thrown when amount entered is greater than balance
+    error InsufficientBalance();
+
+    /// @notice Error is thrown when pool reserve is less than the amount needed
+    error InsufficientPoolReserve(address comptroller, uint256 amount, uint256 poolReserve);
+
+    /// @dev Convertible base asset setter
+    /// @param convertibleBaseAsset_ Address of the convertible base asset
+    /// @custom:event ConvertibleBaseAssetUpdated emit on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when convertible base asset address is zero
+    /// @custom:access Only Governance
+    function setConvertibleBaseAsset(address convertibleBaseAsset_) external onlyOwner {
+        ensureNonzeroAddress(convertibleBaseAsset_);
+        emit ConvertibleBaseAssetUpdated(convertibleBaseAsset, convertibleBaseAsset_);
+        convertibleBaseAsset = convertibleBaseAsset_;
+    }
+
+    /// @dev Risk fund converter setter
+    /// @param riskFundConverter_ Address of the risk fund converter
+    /// @custom:event RiskFundConverterUpdated emit on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when risk fund converter address is zero
+    /// @custom:access Only Governance
+    function setRiskFundConverter(address riskFundConverter_) external onlyOwner {
+        ensureNonzeroAddress(riskFundConverter_);
+        emit RiskFundConverterUpdated(riskFundConverter, riskFundConverter_);
+        riskFundConverter = riskFundConverter_;
+    }
+
+    /// @dev Shortfall contract address setter
+    /// @param shortfallContractAddress_ Address of the auction contract
+    /// @custom:event ShortfallContractUpdated emit on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when shortfall contract address is zero
+    /// @custom:access Only Governance
+    function setShortfallContractAddress(address shortfallContractAddress_) external onlyOwner {
+        ensureNonzeroAddress(shortfallContractAddress_);
+        emit ShortfallContractUpdated(shortfall, shortfallContractAddress_);
+        shortfall = shortfallContractAddress_;
+    }
+
+    /// @dev Transfer tokens for auction to shortfall contract
+    /// @param comptroller Comptroller of the pool
+    /// @param amount Amount to be transferred to the shortfall
+    /// @return Amount of tokens transferred to the shortfall
+    /// @custom:event TransferredReserveForAuction emit on success
+    /// @custom:error InvalidShortfallAddress is thrown when caller is not shortfall contract
+    /// @custom:error InsufficientPoolReserve is thrown when pool reserve is less than the amount needed
+    /// @custom:access Only Shortfall contract
+    function transferReserveForAuction(address comptroller, uint256 amount)
+        external
+        override
+        nonReentrant
+        returns (uint256)
+    {
+        uint256 poolReserve = poolAssetsFunds[comptroller][convertibleBaseAsset];
+
+        if (msg.sender != shortfall) {
+            revert InvalidShortfallAddress();
+        }
+        if (amount > poolReserve) {
+            revert InsufficientPoolReserve(comptroller, amount, poolReserve);
+        }
+
+        unchecked {
+            poolAssetsFunds[comptroller][convertibleBaseAsset] = poolReserve - amount;
+        }
+
+        IERC20Upgradeable(convertibleBaseAsset).safeTransfer(shortfall, amount);
+        emit TransferredReserveForAuction(comptroller, amount);
+
+        return amount;
+    }
+
+    /// @notice Function to sweep baseAsset for pool, Tokens are sent to address(to)
+    /// @param tokenAddress Address of the asset(token)
+    /// @param to Address to which assets will be transferred
+    /// @param amount Amount need to sweep for the pool
+    /// @custom:event Emits SweepToken event on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero
+    /// @custom:error ZeroValueNotAllowed is thrown when amount is zero
+    /// @custom:access Only Governance
+    function sweepToken(
+        address tokenAddress,
+        address to,
+        uint256 amount
+    ) external onlyOwner nonReentrant {
+        ensureNonzeroAddress(tokenAddress);
+        ensureNonzeroAddress(to);
+        ensureNonzeroValue(amount);
+
+        IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);
+        preSweepToken(tokenAddress, amount);
+        token.safeTransfer(to, amount);
+
+        emit SweepToken(tokenAddress, to, amount);
+    }
+
+    /// @notice Function to sweep token from pool
+    /// @param tokenAddress Address of the asset(token)
+    /// @param comptroller Pool address to which assets will be transferred
+    /// @param amount Amount need to sweep from the pool
+    /// @custom:event Emits sweepTokenFromPool event on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/comptroller address is zero
+    /// @custom:error ZeroValueNotAllowed is thrown when amount is zero
+    /// @custom:access Only Governance
+    function sweepTokenFromPool(
+        address tokenAddress,
+        address comptroller,
+        uint256 amount
+    ) external onlyOwner nonReentrant {
+        ensureNonzeroAddress(tokenAddress);
+        ensureNonzeroAddress(comptroller);
+        ensureNonzeroValue(amount);
+
+        uint256 poolReserve = poolAssetsFunds[comptroller][tokenAddress];
+
+        if (amount > poolReserve) {
+            revert InsufficientPoolReserve(comptroller, amount, poolReserve);
+        }
+
+        unchecked {
+            poolAssetsFunds[comptroller][tokenAddress] = poolReserve - amount;
+        }
+
+        IERC20Upgradeable(tokenAddress).safeTransfer(comptroller, amount);
+
+        emit SweepTokenFromPool(tokenAddress, comptroller, amount);
+    }
+
+    /**
+     * @notice Get the Amount of the Base asset in the risk fund for the specific pool.
+     * @param comptroller  Comptroller address(pool).
+     * @return Base Asset's reserve in risk fund.
+     */
+    function getPoolsBaseAssetReserves(address comptroller) external view returns (uint256) {
+        return poolAssetsFunds[comptroller][convertibleBaseAsset];
+    }
+
+    /// @dev Update the reserve of the asset for the specific pool after transferring to risk fund
+    /// @param comptroller Comptroller address (pool)
+    /// @param asset Address of the asset(token)
+    /// @param amount Amount transferred for the pool
+    /// @custom:event PoolAssetsIncreased emits on success
+    /// @custom:error InvalidRiskFundConverter is thrown if caller is not riskFundConverter contract
+    /// @custom:access Only RiskFundConverter contract
+    function updatePoolState(
+        address comptroller,
+        address asset,
+        uint256 amount
+    ) public {
+        if (msg.sender != riskFundConverter) {
+            revert InvalidRiskFundConverter();
+        }
+
+        poolAssetsFunds[comptroller][asset] += amount;
+        emit PoolAssetsIncreased(comptroller, asset, amount);
+    }
+
+    /// @dev Operations to perform before sweeping tokens
+    /// @param tokenAddress Address of the token
+    /// @param amount Amount transferred to address(to)
+    /// @custom:error InsufficientBalance is thrown when amount entered is greater than balance
+    function preSweepToken(address tokenAddress, uint256 amount) internal {
+        uint256 balance = IERC20Upgradeable(tokenAddress).balanceOf(address(this));
+        if (amount > balance) revert InsufficientBalance();
+
+        address[] memory pools = IRiskFundConverter(riskFundConverter).getPools(tokenAddress);
+
+        uint256 assetReserves;
+        uint256 poolsLength = pools.length;
+        for (uint256 i; i < poolsLength; ) {
+            assetReserves += poolAssetsFunds[pools[i]][tokenAddress];
+            unchecked {
+                ++i;
+            }
+        }
+
+        uint256 balanceDiff = balance - assetReserves;
+
+        if (balanceDiff < amount) {
+            uint256 amountDiff;
+            unchecked {
+                amountDiff = amount - balanceDiff;
+            }
+            uint256 distributedShare;
+            for (uint256 i; i < poolsLength; ) {
+                if (poolAssetsFunds[pools[i]][tokenAddress] != 0) {
+                    uint256 poolAmountShare;
+                    if (i < (poolsLength - 1)) {
+                        poolAmountShare = (poolAssetsFunds[pools[i]][tokenAddress] * amount) / assetReserves;
+                        distributedShare += poolAmountShare;
+                    } else {
+                        poolAmountShare = amountDiff - distributedShare;
+                    }
+                    poolAssetsFunds[pools[i]][tokenAddress] -= poolAmountShare;
+                    emit PoolAssetsDecreased(pools[i], tokenAddress, poolAmountShare);
+                }
+                unchecked {
+                    ++i;
+                }
+            }
+        }
+    }
+}

package/contracts/ProtocolReserve/XVSVaultTreasury.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { AccessControlledV8 } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol";
+import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import { ensureNonzeroAddress, ensureNonzeroValue } from "@venusprotocol/solidity-utilities/contracts/validators.sol";
+
+import { IXVSVault } from "../Interfaces/IXVSVault.sol";
+
+/// @title XVSVaultTreasury
+/// @author Venus
+/// @notice XVSVaultTreasury stores the tokens sent by SingleTokenConverter(XVS) and funds XVSVault
+/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion
+contract XVSVaultTreasury is AccessControlledV8, ReentrancyGuardUpgradeable {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+
+    /// @notice The xvs token address
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    address public immutable XVS_ADDRESS;
+
+    /// @notice The xvsvault address
+    address public xvsVault;
+
+    /// @notice Emitted when XVS vault address is updated
+    event XVSVaultUpdated(address indexed oldXVSVault, address indexed newXVSVault);
+
+    /// @notice Emitted when funds transferred to XVSStore address
+    event FundsTransferredToXVSStore(address indexed xvsStore, uint256 amountMantissa);
+
+    /// @notice Thrown when given input amount is zero
+    error InsufficientBalance();
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    /// @param xvsAddress_ XVS token address
+    constructor(address xvsAddress_) {
+        ensureNonzeroAddress(xvsAddress_);
+        XVS_ADDRESS = xvsAddress_;
+
+        // Note that the contract is upgradeable. Use initialize() or reinitializers
+        // to set the state variables.
+        _disableInitializers();
+    }
+
+    /// @param accessControlManager_ Access control manager contract address
+    /// @param xvsVault_ XVSVault address
+    /// @custom:event XVSVaultUpdated emits on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when XVS vault address is zero
+    function initialize(address accessControlManager_, address xvsVault_) public initializer {
+        __AccessControlled_init(accessControlManager_);
+        __ReentrancyGuard_init();
+        _setXVSVault(xvsVault_);
+    }
+
+    /// @dev XVS vault setter
+    /// @param xvsVault_ Address of the XVS vault
+    /// @custom:event XVSVaultUpdated emits on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when XVS vault address is zero
+    function setXVSVault(address xvsVault_) external onlyOwner {
+        _setXVSVault(xvsVault_);
+    }
+
+    /// @notice This function transfers funds to the XVS vault
+    /// @param amountMantissa Amount to be sent to XVS vault
+    /// @custom:event FundsTransferredToXVSStore emits on success
+    /// @custom:error InsufficientBalance is thrown when amount entered is greater than balance
+    /// @custom:access Restricted by ACM
+    function fundXVSVault(uint256 amountMantissa) external nonReentrant {
+        _checkAccessAllowed("fundXVSVault(uint256)");
+        ensureNonzeroValue(amountMantissa);
+
+        uint256 balance = IERC20Upgradeable(XVS_ADDRESS).balanceOf(address(this));
+
+        if (balance < amountMantissa) {
+            revert InsufficientBalance();
+        }
+
+        address xvsStore = IXVSVault(xvsVault).xvsStore();
+        ensureNonzeroAddress(xvsStore);
+        IERC20Upgradeable(XVS_ADDRESS).safeTransfer(xvsStore, amountMantissa);
+
+        emit FundsTransferredToXVSStore(xvsStore, amountMantissa);
+    }
+
+    /// @dev XVS vault setter
+    /// @param xvsVault_ Address of the XVS vault
+    /// @custom:event XVSVaultUpdated emits on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when XVS vault address is zero
+    function _setXVSVault(address xvsVault_) internal {
+        ensureNonzeroAddress(xvsVault_);
+        emit XVSVaultUpdated(xvsVault, xvsVault_);
+        xvsVault = xvsVault_;
+    }
+}