@venusprotocol/venus-protocol 6.1.0-dev.1 → 6.1.0-dev.10

package/contracts/DelegateBorrowers/MoveDebtDelegate.sol

@@ -0,0 +1,179 @@
+// 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";
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { ResilientOracleInterface } from "@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol";
+
+import { approveOrRevert } from "../lib/approveOrRevert.sol";
+import { IVBep20, IComptroller } from "../InterfacesV8.sol";
+
+contract MoveDebtDelegate is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable {
+    /// @dev VToken return value signalling about successful execution
+    uint256 internal constant NO_ERROR = 0;
+
+    /// @notice VToken to repay the debt to
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    IVBep20 public immutable vTokenToRepay;
+
+    /// @notice User to borrow on behalf of
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    address public immutable newBorrower;
+
+    /// @notice Whether to allow borrowing from the corresponding vToken
+    mapping(address => bool) public borrowAllowed;
+
+    /// @notice Emitted when vToken is allowed or denied to be borrowed from
+    event BorrowAllowedSet(address indexed vToken, bool allowed);
+
+    /// @notice Emitted if debt is swapped successfully
+    event DebtMoved(
+        address indexed originalBorrower,
+        address vTokenRepaid,
+        uint256 repaidAmount,
+        address indexed newBorrower,
+        address indexed vTokenBorrowed,
+        uint256 borrowedAmount
+    );
+
+    /// @notice Emitted when the owner transfers tokens, accidentially sent to this contract,
+    ///   to their account
+    event SweptTokens(address indexed token, uint256 amount);
+
+    /// @notice Thrown if VTokens' comptrollers are not equal
+    error ComptrollerMismatch();
+
+    /// @notice Thrown if repayment fails with an error code
+    error RepaymentFailed(uint256 errorCode);
+
+    /// @notice Thrown if borrow fails with an error code
+    error BorrowFailed(uint256 errorCode);
+
+    /// @notice Thrown if borrowing from the corresponding vToken is not allowed
+    error BorrowNotAllowed(address vToken);
+
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+
+    /// @notice Constructor for the implementation contract. Sets immutable variables.
+    /// @param vTokenToRepay_ VToken to repay the debt to
+    /// @param newBorrower_ User to borrow on behalf of
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor(IVBep20 vTokenToRepay_, address newBorrower_) {
+        vTokenToRepay = vTokenToRepay_;
+        newBorrower = newBorrower_;
+        _disableInitializers();
+    }
+
+    function initialize() external initializer {
+        __Ownable2Step_init();
+        __ReentrancyGuard_init();
+    }
+
+    /**
+     * @notice Repays originalBorrower's borrow in vTokenToRepay.underlying() and borrows
+     *   vTokenToBorrow.underlying() on behalf of newBorrower
+     * @param originalBorrower The address of the borrower, whose debt to repay
+     * @param repayAmount The amount to repay in terms of vTokenToRepay.underlying()
+     * @param vTokenToBorrow VToken to borrow from
+     */
+    function moveDebt(address originalBorrower, uint256 repayAmount, IVBep20 vTokenToBorrow) external nonReentrant {
+        if (!borrowAllowed[address(vTokenToBorrow)]) {
+            revert BorrowNotAllowed(address(vTokenToBorrow));
+        }
+        uint256 actualRepaymentAmount = _repay(originalBorrower, repayAmount);
+        uint256 amountToBorrow = _convert(vTokenToRepay, vTokenToBorrow, actualRepaymentAmount);
+        _borrow(vTokenToBorrow, amountToBorrow);
+        emit DebtMoved(
+            originalBorrower,
+            address(vTokenToRepay),
+            actualRepaymentAmount,
+            newBorrower,
+            address(vTokenToBorrow),
+            amountToBorrow
+        );
+    }
+
+    /**
+     * @notice Allows or denies borrowing from the corresponding vToken
+     * @param vTokenToBorrow VToken to borrow from
+     * @param allow Whether to allow borrowing from the corresponding vToken
+     */
+    function setBorrowAllowed(address vTokenToBorrow, bool allow) external onlyOwner {
+        if (borrowAllowed[vTokenToBorrow] != allow) {
+            borrowAllowed[vTokenToBorrow] = allow;
+            emit BorrowAllowedSet(vTokenToBorrow, allow);
+        }
+    }
+
+    /**
+     * @notice Transfers tokens, accidentially sent to this contract, to the owner
+     * @param token ERC-20 token to sweep
+     */
+    function sweepTokens(IERC20Upgradeable token) external onlyOwner {
+        uint256 amount = token.balanceOf(address(this));
+        token.safeTransfer(owner(), amount);
+        emit SweptTokens(address(token), amount);
+    }
+
+    /**
+     * @dev Transfers the funds from the sender and repays a borrow in vToken on behalf of the borrower
+     * @param borrower The address of the borrower, whose debt to repay
+     * @param repayAmount The amount to repay in terms of underlying
+     */
+    function _repay(address borrower, uint256 repayAmount) internal returns (uint256 actualRepaymentAmount) {
+        IERC20Upgradeable underlying = IERC20Upgradeable(vTokenToRepay.underlying());
+        uint256 balanceBefore = underlying.balanceOf(address(this));
+        underlying.safeTransferFrom(msg.sender, address(this), repayAmount);
+        uint256 balanceAfter = underlying.balanceOf(address(this));
+        uint256 repayAmountMinusFee = balanceAfter - balanceBefore;
+
+        uint256 borrowBalanceBefore = vTokenToRepay.borrowBalanceCurrent(borrower);
+        approveOrRevert(underlying, address(vTokenToRepay), repayAmountMinusFee);
+        uint256 err = vTokenToRepay.repayBorrowBehalf(borrower, repayAmountMinusFee);
+        if (err != NO_ERROR) {
+            revert RepaymentFailed(err);
+        }
+        approveOrRevert(underlying, address(vTokenToRepay), 0);
+        uint256 borrowBalanceAfter = vTokenToRepay.borrowBalanceCurrent(borrower);
+        return borrowBalanceBefore - borrowBalanceAfter;
+    }
+
+    /**
+     * @dev Borrows in vToken on behalf of the borrower and transfers the funds to the sender
+     * @param vToken VToken to borrow from
+     * @param borrowAmount The amount to borrow in terms of underlying
+     */
+    function _borrow(IVBep20 vToken, uint256 borrowAmount) internal {
+        IERC20Upgradeable underlying = IERC20Upgradeable(vToken.underlying());
+        uint256 balanceBefore = underlying.balanceOf(address(this));
+        uint256 err = vToken.borrowBehalf(newBorrower, borrowAmount);
+        if (err != NO_ERROR) {
+            revert BorrowFailed(err);
+        }
+        uint256 balanceAfter = underlying.balanceOf(address(this));
+        uint256 actualBorrowedAmount = balanceAfter - balanceBefore;
+        underlying.safeTransfer(msg.sender, actualBorrowedAmount);
+    }
+
+    /**
+     * @dev Converts the value expressed in convertFrom.underlying() to a value
+     *   in convertTo.underlying(), using the oracle price
+     * @param convertFrom VToken to convert from
+     * @param convertTo VToken to convert to
+     * @param amount The amount in convertFrom.underlying()
+     */
+    function _convert(IVBep20 convertFrom, IVBep20 convertTo, uint256 amount) internal view returns (uint256) {
+        IComptroller comptroller = convertFrom.comptroller();
+        if (comptroller != convertTo.comptroller()) {
+            revert ComptrollerMismatch();
+        }
+        ResilientOracleInterface oracle = comptroller.oracle();
+
+        // Decimals are accounted for in the oracle contract
+        uint256 scaledUsdValue = oracle.getUnderlyingPrice(address(convertFrom)) * amount; // the USD value here has 36 decimals
+        return scaledUsdValue / oracle.getUnderlyingPrice(address(convertTo));
+    }
+}

package/contracts/DelegateBorrowers/SwapDebtDelegate.sol

@@ -2,30 +2,14 @@
 
 pragma solidity 0.8.13;
 
-import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { Ownable2StepUpgradeable } from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
+import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { ResilientOracleInterface } from "@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol";
 
-interface IPriceOracle {
-    function getUnderlyingPrice(IVToken vToken) external view returns (uint256);
-}
-
-interface IComptroller {
-    function oracle() external view returns (IPriceOracle);
-}
-
-interface IVToken {
-    function borrowBehalf(address borrower, uint256 borrowAmount) external returns (uint256);
-
-    function repayBorrowBehalf(address borrower, uint256 repayAmount) external returns (uint256);
-
-    function borrowBalanceCurrent(address account) external returns (uint256);
-
-    function comptroller() external view returns (IComptroller);
-
-    function underlying() external view returns (address);
-}
+import { approveOrRevert } from "../lib/approveOrRevert.sol";
+import { IVBep20, IComptroller } from "../InterfacesV8.sol";
 
 contract SwapDebtDelegate is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable {
     /// @dev VToken return value signalling about successful execution
@@ -69,8 +53,8 @@ contract SwapDebtDelegate is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable
      */
     function swapDebt(
         address borrower,
-        IVToken repayTo,
-        IVToken borrowFrom,
+        IVBep20 repayTo,
+        IVBep20 borrowFrom,
         uint256 repayAmount
     ) external onlyOwner nonReentrant {
         uint256 actualRepaymentAmount = _repay(repayTo, borrower, repayAmount);
@@ -96,7 +80,7 @@ contract SwapDebtDelegate is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable
      * @param repayAmount The amount to repay in terms of underlying
      */
     function _repay(
-        IVToken vToken,
+        IVBep20 vToken,
         address borrower,
         uint256 repayAmount
     ) internal returns (uint256 actualRepaymentAmount) {
@@ -123,7 +107,7 @@ contract SwapDebtDelegate is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable
      * @param borrower The address of the borrower, who will own the borrow
      * @param borrowAmount The amount to borrow in terms of underlying
      */
-    function _borrow(IVToken vToken, address borrower, uint256 borrowAmount) internal {
+    function _borrow(IVBep20 vToken, address borrower, uint256 borrowAmount) internal {
         IERC20Upgradeable underlying = IERC20Upgradeable(vToken.underlying());
         uint256 balanceBefore = underlying.balanceOf(address(this));
         uint256 err = vToken.borrowBehalf(borrower, borrowAmount);
@@ -142,15 +126,15 @@ contract SwapDebtDelegate is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable
      * @param convertTo VToken to convert to
      * @param amount The amount in convertFrom.underlying()
      */
-    function _convert(IVToken convertFrom, IVToken convertTo, uint256 amount) internal view returns (uint256) {
+    function _convert(IVBep20 convertFrom, IVBep20 convertTo, uint256 amount) internal view returns (uint256) {
         IComptroller comptroller = convertFrom.comptroller();
         if (comptroller != convertTo.comptroller()) {
             revert ComptrollerMismatch();
         }
-        IPriceOracle oracle = comptroller.oracle();
+        ResilientOracleInterface oracle = comptroller.oracle();
 
         // Decimals are accounted for in the oracle contract
-        uint256 scaledUsdValue = oracle.getUnderlyingPrice(convertFrom) * amount; // the USD value here has 36 decimals
-        return scaledUsdValue / oracle.getUnderlyingPrice(convertTo);
+        uint256 scaledUsdValue = oracle.getUnderlyingPrice(address(convertFrom)) * amount; // the USD value here has 36 decimals
+        return scaledUsdValue / oracle.getUnderlyingPrice(address(convertTo));
     }
 }

package/contracts/{Liquidator/Interfaces.sol → InterfacesV8.sol}

@@ -1,22 +1,27 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.13;
 
-import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { ResilientOracleInterface } from "@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol";
 
 interface IVToken is IERC20Upgradeable {
     function borrowBalanceCurrent(address borrower) external returns (uint256);
 
-    function transfer(address dst, uint256 amount) external returns (bool);
+    function comptroller() external view returns (IComptroller);
 }
 
 interface IVBep20 is IVToken {
-    function underlying() external view returns (address);
+    function borrowBehalf(address borrower, uint256 borrowAmount) external returns (uint256);
+
+    function repayBorrowBehalf(address borrower, uint256 repayAmount) external returns (uint256);
 
     function liquidateBorrow(
         address borrower,
         uint256 repayAmount,
         IVToken vTokenCollateral
     ) external returns (uint256);
+
+    function underlying() external view returns (address);
 }
 
 interface IVBNB is IVToken {
@@ -53,6 +58,8 @@ interface IComptroller {
     function vaiController() external view returns (IVAIController);
 
     function liquidatorContract() external view returns (address);
+
+    function oracle() external view returns (ResilientOracleInterface);
 }
 
 interface ILiquidator {

package/contracts/Liquidator/BUSDLiquidator.sol

@@ -1,14 +1,15 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.13;
 
-import { SafeERC20Upgradeable, IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
 import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 import { Ownable2StepUpgradeable } from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
+import { MANTISSA_ONE } from "@venusprotocol/solidity-utilities/contracts/constants.sol";
+import { ensureNonzeroAddress } from "@venusprotocol/solidity-utilities/contracts/validators.sol";
 
-import { MANTISSA_ONE } from "./constants.sol";
-import { ensureNonzeroAddress } from "./zeroAddress.sol";
-import { approveOrRevert } from "./approveOrRevert.sol";
-import { ILiquidator, IComptroller, IVToken, IVBep20, IVBNB, IVAIController } from "./Interfaces.sol";
+import { approveOrRevert } from "../lib/approveOrRevert.sol";
+import { ILiquidator, IComptroller, IVToken, IVBep20, IVBNB, IVAIController } from "../InterfacesV8.sol";
 
 /**
  * @title BUSDLiquidator

package/contracts/Liquidator/Liquidator.sol

@@ -1,12 +1,13 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.13;
 
-import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
+import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import { Ownable2StepUpgradeable } from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { ensureNonzeroAddress } from "@venusprotocol/solidity-utilities/contracts/validators.sol";
 
-import { ensureNonzeroAddress } from "./zeroAddress.sol";
-import { ILiquidator, IComptroller, IVToken, IVBep20, IVBNB, IVAIController } from "./Interfaces.sol";
+import { ILiquidator, IComptroller, IVToken, IVBep20, IVBNB, IVAIController } from "../InterfacesV8.sol";
 
 /**
  * @title Liquidator

package/contracts/Tokens/Prime/Prime.sol

@@ -5,7 +5,7 @@ import { SafeERC20Upgradeable, IERC20Upgradeable } from "@openzeppelin/contracts
 import { AccessControlledV8 } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol";
 import { ResilientOracleInterface } from "@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol";
 import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
-import { MaxLoopsLimitHelper } from "@venusprotocol/isolated-pools/contracts/MaxLoopsLimitHelper.sol";
+import { MaxLoopsLimitHelper } from "@venusprotocol/solidity-utilities/contracts/MaxLoopsLimitHelper.sol";
 import { IERC20MetadataUpgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
 
 import { PrimeStorageV1 } from "./PrimeStorage.sol";
@@ -30,13 +30,13 @@ contract Prime is IPrime, AccessControlledV8, PausableUpgradeable, MaxLoopsLimit
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
     uint256 public immutable BLOCKS_PER_YEAR;
 
-    /// @notice address of WBNB contract
+    /// @notice address of wrapped native token contract
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
-    address public immutable WBNB;
+    address public immutable WRAPPED_NATIVE_TOKEN;
 
-    /// @notice address of VBNB contract
+    /// @notice address of native market contract
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
-    address public immutable VBNB;
+    address public immutable NATIVE_MARKET;
 
     /// @notice minimum amount of XVS user needs to stake to become a prime member
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
@@ -145,8 +145,8 @@ contract Prime is IPrime, AccessControlledV8, PausableUpgradeable, MaxLoopsLimit
 
     /**
      * @notice Prime constructor
-     * @param _wbnb Address of WBNB
-     * @param _vbnb Address of VBNB
+     * @param _wrappedNativeToken Address of wrapped native token
+     * @param _nativeMarket Address of native market
      * @param _blocksPerYear total blocks per year
      * @param _stakingPeriod total number of seconds for which user needs to stake to claim prime token
      * @param _minimumStakedXVS minimum amount of XVS user needs to stake to become a prime member (scaled by 1e18)
@@ -156,18 +156,16 @@ contract Prime is IPrime, AccessControlledV8, PausableUpgradeable, MaxLoopsLimit
      */
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor(
-        address _wbnb,
-        address _vbnb,
+        address _wrappedNativeToken,
+        address _nativeMarket,
         uint256 _blocksPerYear,
         uint256 _stakingPeriod,
         uint256 _minimumStakedXVS,
         uint256 _maximumXVSCap
     ) {
-        if (_wbnb == address(0)) revert InvalidAddress();
-        if (_vbnb == address(0)) revert InvalidAddress();
         if (_blocksPerYear == 0) revert InvalidBlocksPerYear();
-        WBNB = _wbnb;
-        VBNB = _vbnb;
+        WRAPPED_NATIVE_TOKEN = _wrappedNativeToken;
+        NATIVE_MARKET = _nativeMarket;
         BLOCKS_PER_YEAR = _blocksPerYear;
         STAKING_PERIOD = _stakingPeriod;
         MINIMUM_STAKED_XVS = _minimumStakedXVS;
@@ -1092,13 +1090,13 @@ contract Prime is IPrime, AccessControlledV8, PausableUpgradeable, MaxLoopsLimit
     }
 
     /**
-     * @notice Returns the underlying token associated with the VToken, or WBNB if the market is VBNB
+     * @notice Returns the underlying token associated with the VToken, or wrapped native token if the market is native market
      * @param vToken the market whose underlying token will be returned
-     * @return underlying The address of the underlying token associated with the VToken, or the address of the WBNB token if the market is VBNB
+     * @return underlying The address of the underlying token associated with the VToken, or the address of the WRAPPED_NATIVE_TOKEN token if the market is NATIVE_MARKET
      */
     function _getUnderlying(address vToken) internal view returns (address) {
-        if (vToken == VBNB) {
-            return WBNB;
+        if (vToken == NATIVE_MARKET) {
+            return WRAPPED_NATIVE_TOKEN;
         }
         return IVToken(vToken).underlying();
     }

package/contracts/Tokens/Prime/PrimeLiquidityProvider.sol

@@ -5,7 +5,7 @@ import { SafeERC20Upgradeable, IERC20Upgradeable } from "@openzeppelin/contracts
 import { AccessControlledV8 } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol";
 import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
 import { IPrimeLiquidityProvider } from "./Interfaces/IPrimeLiquidityProvider.sol";
-import { MaxLoopsLimitHelper } from "@venusprotocol/isolated-pools/contracts/MaxLoopsLimitHelper.sol";
+import { MaxLoopsLimitHelper } from "@venusprotocol/solidity-utilities/contracts/MaxLoopsLimitHelper.sol";
 
 /**
  * @title PrimeLiquidityProvider

package/deploy/007-deploy-VTreasuryV8.ts

@@ -8,6 +8,8 @@ interface AdminAccounts {
 const acmAdminAccount: AdminAccounts = {
   sepolia: "0x94fa6078b6b8a26f0b6edffbe6501b22a10470fb", // SEPOLIA MULTISIG
   ethereum: "0x285960C5B22fD66A736C7136967A3eB15e93CC67", // ETHEREUM MULTISIG
+  opbnbtestnet: "0xb15f6EfEbC276A3b9805df81b5FB3D50C2A62BDf", // OPBNBTESTNET MULTISIG
+  opbnbmainnet: "0xC46796a21a3A9FAB6546aF3434F2eBfFd0604207", // OPBNBMAINNET MULTISIG
 };
 
 const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
@@ -15,7 +17,6 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
   const { deploy } = deployments;
   const { deployer } = await getNamedAccounts();
   const deployerSigner = await hre.ethers.getSigner(deployer);
-
   const treasuryInstance = await deploy("VTreasuryV8", {
     from: deployer,
     args: [],

package/deploy/007-deploy-xvs.ts

@@ -0,0 +1,21 @@
+import { DeployFunction } from "hardhat-deploy/types";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  await deploy("XVS", {
+    from: deployer,
+    args: [deployer],
+    log: true,
+    autoMine: true,
+  });
+};
+
+func.tags = ["xvs"];
+
+func.skip = async (hre: HardhatRuntimeEnvironment) => hre.network.live;
+
+export default func;

package/deploy/008-deploy-vaults.ts

@@ -0,0 +1,53 @@
+import { ethers } from "hardhat";
+import { DeployFunction } from "hardhat-deploy/types";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  const xvsVaultDeployment = await deploy("XVSVault", {
+    from: deployer,
+    args: [],
+    log: true,
+    autoMine: true,
+  });
+
+  const xvsVaultAddress = xvsVaultDeployment.address;
+
+  const xvsVaultProxyDeployment = await deploy("XVSVaultProxy", {
+    from: deployer,
+    args: [],
+    log: true,
+    autoMine: true,
+  });
+
+  const xvsVaultProxyAddress = xvsVaultProxyDeployment.address;
+
+  await deploy("XVSStore", {
+    from: deployer,
+    args: [],
+    log: true,
+    autoMine: true,
+  });
+
+  const xvsVault = await ethers.getContract("XVSVault");
+  const xvsStore = await ethers.getContract("XVSStore");
+  const xvsVaultProxy = await ethers.getContract("XVSVaultProxy");
+
+  // Become Implementation of XVSVaultProxy
+  const tx = await xvsVaultProxy._setPendingImplementation(xvsVaultAddress);
+  await tx.wait();
+
+  await xvsVault._become(xvsVaultProxyAddress);
+  await tx.wait();
+
+  // Set new owner to xvs store
+  await xvsStore.setNewOwner(xvsVaultProxyAddress);
+  await tx.wait();
+};
+
+func.tags = ["xvs-vault"];
+
+export default func;

package/deploy/009-configure-vaults.ts

@@ -0,0 +1,60 @@
+import { ethers } from "hardhat";
+import { DeployFunction } from "hardhat-deploy/types";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+interface AdminAccounts {
+  [key: string]: string;
+}
+const adminAccount: AdminAccounts = {
+  sepolia: "0x94fa6078b6b8a26f0b6edffbe6501b22a10470fb", // SEPOLIA MULTISIG
+  ethereum: "0x285960C5B22fD66A736C7136967A3eB15e93CC67", // ETHEREUM MULTISIG
+};
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { getNamedAccounts } = hre;
+  const { deployer } = await getNamedAccounts();
+
+  const accessControlManager = await ethers.getContract("AccessControlManager");
+
+  const xvs = await ethers.getContract("XVS");
+  const xvsVaultProxyDeployment = await ethers.getContract("XVSVaultProxy");
+  const xvsStoreDeployment = await ethers.getContract("XVSStore");
+
+  const xvsVaultProxy = await ethers.getContractAt("XVSVault", xvsVaultProxyDeployment.address);
+
+  let txn = await xvsVaultProxy.setXvsStore(xvs.address, xvsStoreDeployment.address);
+  await txn.wait();
+
+  txn = await xvsVaultProxy.setAccessControl(accessControlManager.address);
+  await txn.wait();
+
+  if (!hre.network.live) {
+    const tx = await accessControlManager.giveCallPermission(
+      ethers.constants.AddressZero,
+      "add(address,uint256,address,uint256,uint256)",
+      deployer,
+    );
+    await tx.wait();
+
+    // Add token pool to xvs vault
+    const allocPoint = 100;
+    const token = xvs.address;
+    const rewardToken = xvs.address;
+    const rewardPerBlock = "61805555555555555";
+    const lockPeriod = 604800;
+
+    await xvsVaultProxy.add(rewardToken, allocPoint, token, rewardPerBlock, lockPeriod);
+  } else {
+    const owner = adminAccount[hre.network.name];
+    console.log("Please accept ownership of vault and store");
+    txn = await xvsVaultProxyDeployment._setPendingAdmin(owner);
+    await txn.wait();
+
+    txn = await xvsStoreDeployment.setPendingAdmin(owner);
+    await txn.wait();
+  }
+};
+
+func.tags = ["xvs-vault"];
+
+export default func;